});

}

function registeredRouteAt(registerHttpRoute: ReturnType<typeof vi.fn>, index: number) {

const call = registerHttpRoute.mock.calls[index];

if (!call) {

throw new Error(`expected registered HTTP route ${index}`);

}

return call[0] as {

handler: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;

};

}

describe("registerSlackPluginHttpRoutes", () => {

it("registers account webhook paths without resolving unresolved token refs", () => {

const registerHttpRoute = vi.fn();

try {

registerSlackPluginHttpRoutes(createApi({}, registerHttpRoute));

const route = registerHttpRoute.mock.calls[0]?.[0] as

| {

handler: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;

}

| undefined;

const route = registeredRouteAt(registerHttpRoute, 0);

const req = { url: "/slack/events" } as IncomingMessage;

const res = {} as ServerResponse;

await expect(route?.handler(req, res)).resolves.toBe(true);

await expect(route.handler(req, res)).resolves.toBe(true);

expect(routeHandler).toHaveBeenCalledWith(req, res);

} finally {

} as SlackMessageEvent;

}

function firstBindingRouteRequest() {

const [call] = resolveConfiguredBindingRouteMock.mock.calls;

if (!call) {

throw new Error("expected configured binding route call");

}

return call[0];

}

describe("thread-level session keys", () => {

beforeEach(() => {

resolveConfiguredBindingRouteMock.mockReset();

});

expect(resolveConfiguredBindingRouteMock).toHaveBeenCalledTimes(1);

const [bindingRouteRequest] = resolveConfiguredBindingRouteMock.mock.calls[0];

const bindingRouteRequest = firstBindingRouteRequest();

expect(bindingRouteRequest).toEqual({

cfg: ctx.cfg,

route: {

await deliverReplies(baseParams());

expect(sendMock).toHaveBeenCalledOnce();

expect(sendMock.mock.calls[0][2]).not.toHaveProperty("identity");

const [, , options] = requireSendCall();

expect(options).not.toHaveProperty("identity");

});

it("delivers block-only replies through to sendMessageSlack", async () => {