Add Slack parity baseline tests (#152)

* Add Slack parity baseline tests

- Add shared Slack test helpers and a baseline coverage matrix.

- Add Slack WebClient conformance and event dispatch baseline tests.

- Alias Slack Vitest runs to the TypeScript core runtime.

* Cover Slack OAuth callback route

* Make Slack SDK tests bind loopback

Author: ctate

packages/@emulators/slack/package.json

@@ -38,6 +38,7 @@
     "@emulators/core": "workspace:*"
   },
   "devDependencies": {
+    "@slack/web-api": "^7.16.0",
     "tsup": "^8",
     "typescript": "^5.7",
     "vitest": "^4.1.0"

packages/@emulators/slack/src/__tests__/coverage.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { slackCoverageMatrix } from "./slack-coverage.js";
+import { createSlackTestApp } from "./helpers.js";
+
+interface RegisteredRoute {
+  method: string;
+  compiled: {
+    pattern: string;
+  };
+}
+
+function registeredSlackRoutes(): string[] {
+  const { app } = createSlackTestApp();
+  const routes = (app as unknown as { routes: RegisteredRoute[] }).routes;
+  return routes.map((route) => `${route.method} ${route.compiled.pattern}`).sort();
+}
+
+describe("Slack coverage matrix", () => {
+  it("has unique method entries", () => {
+    const methods = slackCoverageMatrix.map((entry) => entry.method);
+    expect(new Set(methods).size).toBe(methods.length);
+  });
+
+  it("maps every registered endpoint to at least one test file", () => {
+    const currentEntries = slackCoverageMatrix.filter((entry) => entry.status !== "not_started");
+    expect(currentEntries.length).toBeGreaterThan(0);
+    expect(currentEntries.map((entry) => entry.route).sort()).toEqual(registeredSlackRoutes());
+
+    for (const entry of currentEntries) {
+      expect(entry.route).toMatch(/^(GET|POST) /);
+      expect(entry.testedBy.length, entry.method).toBeGreaterThan(0);
+    }
+  });
+
+  it("keeps planned gaps explicit", () => {
+    const planned = slackCoverageMatrix.filter((entry) => entry.status === "not_started");
+    expect(planned.map((entry) => entry.method)).toEqual(
+      expect.arrayContaining(["chat.postEphemeral", "files.getUploadURLExternal", "views.publish"]),
+    );
+    for (const entry of planned) {
+      expect(entry.notes).toMatch(/Planned|future/i);
+    }
+  });
+});

packages/@emulators/slack/src/__tests__/helpers.ts

@@ -0,0 +1,126 @@
+import type { AddressInfo } from "node:net";
+import {
+  Hono,
+  Store,
+  WebhookDispatcher,
+  authMiddleware,
+  createApiErrorHandler,
+  createErrorHandler,
+  serve,
+} from "@emulators/core";
+import type { AppEnv, TokenMap } from "@emulators/core";
+import type { Server } from "node:http";
+import { vi } from "vitest";
+import { getSlackStore, slackPlugin } from "../index.js";
+
+export const slackTestBaseUrl = "http://localhost:4000";
+export const slackTestToken = "xoxb-test-token";
+
+export interface SlackTestHttpApp {
+  fetch: (request: Request) => Promise<Response>;
+  request: (input: string | Request, init?: RequestInit) => Promise<Response>;
+}
+
+export interface SlackTestApp {
+  app: SlackTestHttpApp;
+  store: Store;
+  webhooks: WebhookDispatcher;
+  tokenMap: TokenMap;
+}
+
+export interface SlackTestEmulator extends SlackTestApp {
+  url: string;
+  close: () => Promise<void>;
+}
+
+export function createSlackTestApp(): SlackTestApp {
+  const store = new Store();
+  const webhooks = new WebhookDispatcher();
+  const tokenMap: TokenMap = new Map();
+  tokenMap.set(slackTestToken, {
+    login: "U000000001",
+    id: 1,
+    scopes: ["chat:write", "channels:read", "users:read", "reactions:write"],
+  });
+
+  const app = new Hono<AppEnv>() as Hono<AppEnv> & SlackTestHttpApp;
+  app.onError(createApiErrorHandler());
+  app.use("*", createErrorHandler());
+  app.use("*", (authMiddleware as (tokens: TokenMap) => ReturnType<typeof authMiddleware>)(tokenMap));
+  slackPlugin.register!(app, store, webhooks, slackTestBaseUrl, tokenMap);
+  slackPlugin.seed?.(store, slackTestBaseUrl);
+
+  const ss = getSlackStore(store);
+  const firstUser = ss.users.all()[0];
+  if (firstUser) {
+    ss.users.update(firstUser.id, { user_id: "U000000001" });
+  }
+
+  return { app, store, webhooks, tokenMap };
+}
+
+export function authHeaders(contentType = "application/json"): Record<string, string> {
+  return { Authorization: `Bearer ${slackTestToken}`, "Content-Type": contentType };
+}
+
+export async function startSlackTestEmulator(
+  customize?: (setup: SlackTestApp) => void | Promise<void>,
+): Promise<SlackTestEmulator> {
+  const setup = createSlackTestApp();
+  await customize?.(setup);
+
+  const server = serve({ fetch: setup.app.fetch, port: 0, hostname: "127.0.0.1" }) as unknown as Server;
+  await new Promise<void>((resolve, reject) => {
+    server.once("listening", () => resolve());
+    server.once("error", reject);
+  });
+
+  const { port } = server.address() as AddressInfo;
+  return {
+    ...setup,
+    url: `http://127.0.0.1:${port}`,
+    close: () =>
+      new Promise<void>((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+      }),
+  };
+}
+
+export interface CapturedFetchRequest {
+  url: string;
+  init: RequestInit;
+}
+
+export function captureFetchRequests(status = 200): {
+  requests: CapturedFetchRequest[];
+  jsonBodies: () => unknown[];
+} {
+  const requests: CapturedFetchRequest[] = [];
+
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
+      requests.push({ url: String(input), init: init ?? {} });
+      return { ok: status >= 200 && status < 300, status };
+    }),
+  );
+
+  return {
+    requests,
+    jsonBodies: () =>
+      requests.map((request) => {
+        const body = request.init.body;
+        if (typeof body !== "string") return body;
+        return JSON.parse(body);
+      }),
+  };
+}
+
+export function registerSlackEventSubscription(webhooks: WebhookDispatcher, events: string[] = ["*"]): void {
+  webhooks.register({
+    url: "https://hooks.example/slack",
+    events,
+    active: true,
+    owner: "slack",
+  });
+}