refactor(shared): replace vi.mock with injected dep in resolve-users

packages/shared/src/slack/resolve-users.test.ts

@@ -1,78 +1,63 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type * as ClientModule from "./client";
-
-const { mockGetUserInfo } = vi.hoisted(() => ({
-  mockGetUserInfo: vi.fn(),
-}));
-
-vi.mock("./client", async () => {
-  const actual = await vi.importActual<typeof ClientModule>("./client");
-  return {
-    ...actual,
-    getUserInfo: mockGetUserInfo,
-  };
-});
-
-import { resolveUserNames } from "./resolve-users";
+import { describe, expect, it } from "vitest";
+import type { SlackEnvelope, SlackUser } from "./client";
+import { resolveUserNames, type GetUserInfo } from "./resolve-users";
 
 describe("resolveUserNames", () => {
-  beforeEach(() => {
-    mockGetUserInfo.mockReset();
-  });
   it("resolves display_name when available", async () => {
-    mockGetUserInfo.mockResolvedValue({
+    const fakeGetUserInfo: GetUserInfo = async (_token, _userId) => ({
       ok: true,
       user: { id: "U1", name: "alice", profile: { display_name: "Alice S" } },
     });
 
-    const result = await resolveUserNames("token", ["U1"]);
+    const result = await resolveUserNames("token", ["U1"], fakeGetUserInfo);
     expect(result.get("U1")).toBe("Alice S");
   });
 
   it("falls back to name when display_name is empty", async () => {
-    mockGetUserInfo.mockResolvedValue({
+    const fakeGetUserInfo: GetUserInfo = async (_token, _userId) => ({
       ok: true,
       user: { id: "U2", name: "bob.jones", profile: { display_name: "" } },
     });
 
-    const result = await resolveUserNames("token", ["U2"]);
+    const result = await resolveUserNames("token", ["U2"], fakeGetUserInfo);
     expect(result.get("U2")).toBe("bob.jones");
   });
 
   it("falls back to user ID when API fails", async () => {
-    mockGetUserInfo.mockRejectedValue(new Error("network error"));
+    const fakeGetUserInfo: GetUserInfo = async (_token, _userId) => {
+      throw new Error("network error");
+    };
 
-    const result = await resolveUserNames("token", ["U3"]);
+    const result = await resolveUserNames("token", ["U3"], fakeGetUserInfo);
     // Promise.allSettled catches the rejection — ID is not in the map
     expect(result.has("U3")).toBe(false);
   });
 
   it("falls back to user ID when user info is missing", async () => {
-    mockGetUserInfo.mockResolvedValue({ ok: false, error: "user_not_found" });
+    const fakeGetUserInfo: GetUserInfo = async (_token, _userId) => ({
+      ok: false,
+      error: "user_not_found",
+    });
 
-    const result = await resolveUserNames("token", ["U4"]);
+    const result = await resolveUserNames("token", ["U4"], fakeGetUserInfo);
     expect(result.get("U4")).toBe("U4");
   });
 
   it("resolves multiple users in parallel", async () => {
-    mockGetUserInfo
-      .mockResolvedValueOnce({
-        ok: true,
-        user: { id: "U1", name: "alice", profile: { display_name: "Alice" } },
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        user: { id: "U2", name: "bob", profile: { display_name: "Bob" } },
-      });
+    const responses: Record<string, SlackEnvelope<{ user: SlackUser }>> = {
+      U1: { ok: true, user: { id: "U1", name: "alice", profile: { display_name: "Alice" } } },
+      U2: { ok: true, user: { id: "U2", name: "bob", profile: { display_name: "Bob" } } },
+    };
+    const fakeGetUserInfo: GetUserInfo = async (_token, userId) => responses[userId]!;
 
-    const result = await resolveUserNames("token", ["U1", "U2"]);
+    const result = await resolveUserNames("token", ["U1", "U2"], fakeGetUserInfo);
     expect(result.get("U1")).toBe("Alice");
     expect(result.get("U2")).toBe("Bob");
     expect(result.size).toBe(2);
   });
 
   it("does not include real_name in fallback chain", async () => {
-    mockGetUserInfo.mockResolvedValue({
+    const fakeGetUserInfo: GetUserInfo = async (_token, _userId) => ({
       ok: true,
       user: {
         id: "U5",
@@ -82,14 +67,20 @@ describe("resolveUserNames", () => {
       },
     });
 
-    const result = await resolveUserNames("token", ["U5"]);
+    const result = await resolveUserNames("token", ["U5"], fakeGetUserInfo);
     // Should use name (jdoe), not real_name (John Doe)
     expect(result.get("U5")).toBe("jdoe");
   });
 
   it("returns empty map for empty input", async () => {
-    const result = await resolveUserNames("token", []);
+    let callCount = 0;
+    const fakeGetUserInfo: GetUserInfo = async (_token, _userId) => {
+      callCount++;
+      return { ok: true, user: { id: "X", name: "x" } };
+    };
+
+    const result = await resolveUserNames("token", [], fakeGetUserInfo);
     expect(result.size).toBe(0);
-    expect(mockGetUserInfo).not.toHaveBeenCalled();
+    expect(callCount).toBe(0);
   });
 });

packages/shared/src/slack/resolve-users.ts

@@ -1,4 +1,6 @@
-import { getUserInfo } from "./client";
+import { getUserInfo as defaultGetUserInfo } from "./client";
+
+export type GetUserInfo = (token: string, userId: string) => ReturnType<typeof defaultGetUserInfo>;
 
 /**
  * Resolve Slack user IDs to display names.
@@ -10,7 +12,8 @@ import { getUserInfo } from "./client";
  */
 export async function resolveUserNames(
   token: string,
-  userIds: string[]
+  userIds: string[],
+  getUserInfo: GetUserInfo = defaultGetUserInfo
 ): Promise<Map<string, string>> {
   const names = new Map<string, string>();
   const results = await Promise.allSettled(