github/openclaw
1
1
Fork 0
mirror of https://github.com/openclaw/openclaw.git synced 2026-04-25 03:04:29 -04:00
Code Issues Packages Projects Releases Wiki Activity

refactor(test): share slack monitor helpers

Browse Source
This commit is contained in:
Peter Steinberger
2026-02-14 23:37:10 +00:00
parent 25b048dc43
commit 61371a712b
4 changed files with 107 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
src/slack/monitor.test-helpers.ts
View File

@@ -1,6 +1,11 @@
import { Mock, vi } from "vitest"; import { Mock, vi } from "vitest";
type SlackHandler = (args: unknown) => Promise<void>; type SlackHandler = (args: unknown) => Promise<void>;
type SlackProviderMonitor = (params: {
botToken: string;
appToken: string;
abortSignal: AbortSignal;
}) => Promise<unknown>;
const slackTestState: { const slackTestState: {
config: Record<string, unknown>; config: Record<string, unknown>;
@@ -43,6 +48,57 @@ export async function waitForSlackEvent(name: string) {
} }
} }
export function startSlackMonitor(
monitorSlackProvider: SlackProviderMonitor,
opts?: { botToken?: string; appToken?: string },
) {
const controller = new AbortController();
const run = monitorSlackProvider({
botToken: opts?.botToken ?? "bot-token",
appToken: opts?.appToken ?? "app-token",
abortSignal: controller.signal,
});
return { controller, run };
}
export async function getSlackHandlerOrThrow(name: string) {
await waitForSlackEvent(name);
const handler = getSlackHandlers()?.get(name);
if (!handler) {
throw new Error(`Slack ${name} handler not registered`);
}
return handler;
}
export async function stopSlackMonitor(params: {
controller: AbortController;
run: Promise<unknown>;
}) {
await flush();
params.controller.abort();
await params.run;
}
export async function runSlackEventOnce(
monitorSlackProvider: SlackProviderMonitor,
name: string,
args: unknown,
opts?: { botToken?: string; appToken?: string },
) {
const { controller, run } = startSlackMonitor(monitorSlackProvider, opts);
const handler = await getSlackHandlerOrThrow(name);
await handler(args);
await stopSlackMonitor({ controller, run });
}
export async function runSlackMessageOnce(
monitorSlackProvider: SlackProviderMonitor,
args: unknown,
opts?: { botToken?: string; appToken?: string },
) {
await runSlackEventOnce(monitorSlackProvider, "message", args, opts);
}
export const defaultSlackTestConfig = () => ({ export const defaultSlackTestConfig = () => ({
messages: { messages: {
responsePrefix: "PFX", responsePrefix: "PFX",

82
src/slack/monitor.tool-result.forces-thread-replies-replytoid-is-set.test.ts
View File

@@ -2,12 +2,13 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
import { resetInboundDedupe } from "../auto-reply/reply/inbound-dedupe.js"; import { resetInboundDedupe } from "../auto-reply/reply/inbound-dedupe.js";
import { import {
defaultSlackTestConfig, defaultSlackTestConfig,
flush,
getSlackClient, getSlackClient,
getSlackHandlers, getSlackHandlerOrThrow,
getSlackTestState, getSlackTestState,
resetSlackTestState, resetSlackTestState,
waitForSlackEvent, runSlackMessageOnce,
startSlackMonitor,
stopSlackMonitor,
} from "./monitor.test-helpers.js"; } from "./monitor.test-helpers.js";
const { monitorSlackProvider } = await import("./monitor.js"); const { monitorSlackProvider } = await import("./monitor.js");
@@ -39,20 +40,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}; };
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -63,10 +51,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: "555" }); expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: "555" });
}); });
@@ -84,20 +68,7 @@ describe("monitorSlackProvider tool results", () => {
channel: { name: "general", is_channel: true }, channel: { name: "general", is_channel: true },
}); });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -108,10 +79,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(reactMock).toHaveBeenCalledWith({ expect(reactMock).toHaveBeenCalledWith({
channel: "C1", channel: "C1",
timestamp: "456", timestamp: "456",
@@ -131,20 +98,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}; };
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -155,10 +109,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).not.toHaveBeenCalled(); expect(replyMock).not.toHaveBeenCalled();
expect(upsertPairingRequestMock).toHaveBeenCalled(); expect(upsertPairingRequestMock).toHaveBeenCalled();
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
@@ -181,18 +131,8 @@ describe("monitorSlackProvider tool results", () => {
.mockResolvedValueOnce({ code: "PAIRCODE", created: true }) .mockResolvedValueOnce({ code: "PAIRCODE", created: true })
.mockResolvedValueOnce({ code: "PAIRCODE", created: false }); .mockResolvedValueOnce({ code: "PAIRCODE", created: false });
const controller = new AbortController(); const { controller, run } = startSlackMonitor(monitorSlackProvider);
const run = monitorSlackProvider({ const handler = await getSlackHandlerOrThrow("message");
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
const baseEvent = { const baseEvent = {
type: "message", type: "message",
@@ -206,9 +146,7 @@ describe("monitorSlackProvider tool results", () => {
await handler({ event: baseEvent }); await handler({ event: baseEvent });
await handler({ event: { ...baseEvent, ts: "124", text: "hello again" } }); await handler({ event: { ...baseEvent, ts: "124", text: "hello again" } });
await flush(); await stopSlackMonitor({ controller, run });
controller.abort();
await run;
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
}); });

255
src/slack/monitor.tool-result.sends-tool-summaries-responseprefix.test.ts
View File

@@ -4,12 +4,13 @@ import { resetInboundDedupe } from "../auto-reply/reply/inbound-dedupe.js";
import { CURRENT_MESSAGE_MARKER } from "../auto-reply/reply/mentions.js"; import { CURRENT_MESSAGE_MARKER } from "../auto-reply/reply/mentions.js";
import { import {
defaultSlackTestConfig, defaultSlackTestConfig,
flush,
getSlackTestState, getSlackTestState,
getSlackClient, getSlackClient,
getSlackHandlers, getSlackHandlerOrThrow,
resetSlackTestState, resetSlackTestState,
waitForSlackEvent, runSlackMessageOnce,
startSlackMonitor,
stopSlackMonitor,
} from "./monitor.test-helpers.js"; } from "./monitor.test-helpers.js";
const { monitorSlackProvider } = await import("./monitor.js"); const { monitorSlackProvider } = await import("./monitor.js");
@@ -26,20 +27,7 @@ describe("monitorSlackProvider tool results", () => {
it("skips tool summaries with responsePrefix", async () => { it("skips tool summaries with responsePrefix", async () => {
replyMock.mockResolvedValue({ text: "final reply" }); replyMock.mockResolvedValue({ text: "final reply" });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -50,10 +38,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
expect(sendMock.mock.calls[0][1]).toBe("PFX final reply"); expect(sendMock.mock.calls[0][1]).toBe("PFX final reply");
}); });
@@ -69,34 +53,21 @@ describe("monitorSlackProvider tool results", () => {
api_app_id: "A1", api_app_id: "A1",
}); });
const controller = new AbortController(); await runSlackMessageOnce(
const run = monitorSlackProvider({ monitorSlackProvider,
botToken: "bot-token", {
appToken: "xapp-1-A1-abc", body: { api_app_id: "A2", team_id: "T1" },
abortSignal: controller.signal, event: {
}); type: "message",
user: "U1",
await waitForSlackEvent("message"); text: "hello",
const handler = getSlackHandlers()?.get("message"); ts: "123",
if (!handler) { channel: "C1",
throw new Error("Slack message handler not registered"); channel_type: "im",
} },
await handler({
body: { api_app_id: "A2", team_id: "T1" },
event: {
type: "message",
user: "U1",
text: "hello",
ts: "123",
channel: "C1",
channel_type: "im",
}, },
}); { appToken: "xapp-1-A1-abc" },
);
await flush();
controller.abort();
await run;
expect(sendMock).not.toHaveBeenCalled(); expect(sendMock).not.toHaveBeenCalled();
expect(replyMock).not.toHaveBeenCalled(); expect(replyMock).not.toHaveBeenCalled();
@@ -134,20 +105,7 @@ describe("monitorSlackProvider tool results", () => {
replyMock.mockResolvedValue({ text: "final reply" }); replyMock.mockResolvedValue({ text: "final reply" });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -158,10 +116,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
expect(sendMock.mock.calls[0][1]).toBe("final reply"); expect(sendMock.mock.calls[0][1]).toBe("final reply");
}); });
@@ -184,18 +138,8 @@ describe("monitorSlackProvider tool results", () => {
return undefined; return undefined;
}); });
const controller = new AbortController(); const { controller, run } = startSlackMonitor(monitorSlackProvider);
const run = monitorSlackProvider({ const handler = await getSlackHandlerOrThrow("message");
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({ await handler({
event: { event: {
@@ -219,9 +163,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush(); await stopSlackMonitor({ controller, run });
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(2); expect(replyMock).toHaveBeenCalledTimes(2);
expect(capturedCtx.Body).not.toContain(HISTORY_CONTEXT_MARKER); expect(capturedCtx.Body).not.toContain(HISTORY_CONTEXT_MARKER);
@@ -249,18 +191,8 @@ describe("monitorSlackProvider tool results", () => {
return undefined; return undefined;
}); });
const controller = new AbortController(); const { controller, run } = startSlackMonitor(monitorSlackProvider);
const run = monitorSlackProvider({ const handler = await getSlackHandlerOrThrow("message");
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({ await handler({
event: { event: {
@@ -298,9 +230,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush(); await stopSlackMonitor({ controller, run });
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(2); expect(replyMock).toHaveBeenCalledTimes(2);
expect(capturedCtx[0]?.Body).toContain("thread-a-one"); expect(capturedCtx[0]?.Body).toContain("thread-a-one");
@@ -314,20 +244,7 @@ describe("monitorSlackProvider tool results", () => {
return { text: "final reply" }; return { text: "final reply" };
}); });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -338,10 +255,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
const client = getSlackClient() as { const client = getSlackClient() as {
assistant?: { threads?: { setStatus?: ReturnType<typeof vi.fn> } }; assistant?: { threads?: { setStatus?: ReturnType<typeof vi.fn> } };
}; };
@@ -376,20 +289,7 @@ describe("monitorSlackProvider tool results", () => {
}; };
replyMock.mockResolvedValue({ text: "hi" }); replyMock.mockResolvedValue({ text: "hi" });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -400,10 +300,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
expect(replyMock.mock.calls[0][0].WasMentioned).toBe(true); expect(replyMock.mock.calls[0][0].WasMentioned).toBe(true);
}); });
@@ -423,20 +319,7 @@ describe("monitorSlackProvider tool results", () => {
}; };
replyMock.mockResolvedValue({ text: "hi" }); replyMock.mockResolvedValue({ text: "hi" });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -447,10 +330,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
expect(replyMock.mock.calls[0][0].WasMentioned).toBe(true); expect(replyMock.mock.calls[0][0].WasMentioned).toBe(true);
}); });
@@ -466,20 +345,7 @@ describe("monitorSlackProvider tool results", () => {
}; };
replyMock.mockResolvedValue({ text: "hi" }); replyMock.mockResolvedValue({ text: "hi" });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -492,10 +358,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
expect(replyMock.mock.calls[0][0].WasMentioned).toBe(true); expect(replyMock.mock.calls[0][0].WasMentioned).toBe(true);
}); });
@@ -512,20 +374,7 @@ describe("monitorSlackProvider tool results", () => {
}; };
replyMock.mockResolvedValue({ text: "hi" }); replyMock.mockResolvedValue({ text: "hi" });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -536,10 +385,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
expect(replyMock.mock.calls[0][0].WasMentioned).toBe(false); expect(replyMock.mock.calls[0][0].WasMentioned).toBe(false);
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
@@ -548,20 +393,7 @@ describe("monitorSlackProvider tool results", () => {
it("treats control commands as mentions for group bypass", async () => { it("treats control commands as mentions for group bypass", async () => {
replyMock.mockResolvedValue({ text: "ok" }); replyMock.mockResolvedValue({ text: "ok" });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -572,10 +404,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
expect(replyMock.mock.calls[0][0].WasMentioned).toBe(true); expect(replyMock.mock.calls[0][0].WasMentioned).toBe(true);
}); });
@@ -596,20 +424,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}; };
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -621,10 +436,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: "456" }); expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: "456" });
}); });

137
src/slack/monitor.tool-result.threads-top-level-replies-replytomode-is-all.test.ts
View File

@@ -2,12 +2,10 @@ import { beforeEach, describe, expect, it } from "vitest";
import { resetInboundDedupe } from "../auto-reply/reply/inbound-dedupe.js"; import { resetInboundDedupe } from "../auto-reply/reply/inbound-dedupe.js";
import { import {
defaultSlackTestConfig, defaultSlackTestConfig,
flush,
getSlackClient, getSlackClient,
getSlackHandlers,
getSlackTestState, getSlackTestState,
resetSlackTestState, resetSlackTestState,
waitForSlackEvent, runSlackMessageOnce,
} from "./monitor.test-helpers.js"; } from "./monitor.test-helpers.js";
const { monitorSlackProvider } = await import("./monitor.js"); const { monitorSlackProvider } = await import("./monitor.js");
@@ -37,20 +35,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}; };
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -61,10 +46,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: "123" }); expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: "123" });
}); });
@@ -72,20 +53,7 @@ describe("monitorSlackProvider tool results", () => {
it("treats parent_user_id as a thread reply even when thread_ts matches ts", async () => { it("treats parent_user_id as a thread reply even when thread_ts matches ts", async () => {
replyMock.mockResolvedValue({ text: "thread reply" }); replyMock.mockResolvedValue({ text: "thread reply" });
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -98,10 +66,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
const ctx = replyMock.mock.calls[0]?.[0] as { const ctx = replyMock.mock.calls[0]?.[0] as {
SessionKey?: string; SessionKey?: string;
@@ -125,20 +89,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}; };
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -150,10 +101,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
const ctx = replyMock.mock.calls[0]?.[0] as { const ctx = replyMock.mock.calls[0]?.[0] as {
SessionKey?: string; SessionKey?: string;
@@ -188,20 +135,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}; };
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -213,10 +147,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
const ctx = replyMock.mock.calls[0]?.[0] as { const ctx = replyMock.mock.calls[0]?.[0] as {
SessionKey?: string; SessionKey?: string;
@@ -256,20 +186,7 @@ describe("monitorSlackProvider tool results", () => {
}); });
} }
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -281,10 +198,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(replyMock).toHaveBeenCalledTimes(1); expect(replyMock).toHaveBeenCalledTimes(1);
const ctx = replyMock.mock.calls[0]?.[0] as { const ctx = replyMock.mock.calls[0]?.[0] as {
SessionKey?: string; SessionKey?: string;
@@ -310,20 +223,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}; };
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -334,10 +234,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: undefined }); expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: undefined });
}); });
@@ -358,20 +254,7 @@ describe("monitorSlackProvider tool results", () => {
}, },
}; };
const controller = new AbortController(); await runSlackMessageOnce(monitorSlackProvider, {
const run = monitorSlackProvider({
botToken: "bot-token",
appToken: "app-token",
abortSignal: controller.signal,
});
await waitForSlackEvent("message");
const handler = getSlackHandlers()?.get("message");
if (!handler) {
throw new Error("Slack message handler not registered");
}
await handler({
event: { event: {
type: "message", type: "message",
user: "U1", user: "U1",
@@ -382,10 +265,6 @@ describe("monitorSlackProvider tool results", () => {
}, },
}); });
await flush();
controller.abort();
await run;
expect(sendMock).toHaveBeenCalledTimes(1); expect(sendMock).toHaveBeenCalledTimes(1);
// First reply starts a thread under the incoming message // First reply starts a thread under the incoming message
expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: "789" }); expect(sendMock.mock.calls[0][2]).toMatchObject({ threadTs: "789" });