test: quiet expected error logging

Author: vicary

src/handlers/event.test.ts

@@ -2,6 +2,7 @@ import { assertEquals } from "jsr:@std/assert@^1.0.0";
 import { describe, it } from "jsr:@std/testing@^1.0.0/bdd";
 import { createEventHandler } from "./event.ts";
 import { resolveContextLimit } from "../services/context-limit.ts";
+import { setLoggerSilentOverride } from "../services/logger.ts";
 import type { SessionState } from "../session.ts";
 
 class FakeClock {
@@ -1187,46 +1188,52 @@ describe("event handler", () => {
     };
     const { handler } = createHandler(sessionManager, { sdkClient });
 
-    await handler({
-      event: {
-        type: "message.updated",
-        properties: {
-          info: {
-            id: "m1",
-            sessionID: "session-1",
-            role: "assistant",
-            time: { created: 1, completed: 2 },
-            tokens: { output: 10 },
-            providerID: "openai",
-            modelID: "gpt-5",
+    try {
+      setLoggerSilentOverride(true);
+
+      await handler({
+        event: {
+          type: "message.updated",
+          properties: {
+            info: {
+              id: "m1",
+              sessionID: "session-1",
+              role: "assistant",
+              time: { created: 1, completed: 2 },
+              tokens: { output: 10 },
+              providerID: "openai",
+              modelID: "gpt-5",
+            },
           },
-        },
-      } as never,
-    });
-    await flushPromises();
-
-    assertEquals(state.contextLimit, 200_000);
-
-    await handler({
-      event: {
-        type: "message.updated",
-        properties: {
-          info: {
-            id: "m2",
-            sessionID: "session-1",
-            role: "assistant",
-            time: { created: 3, completed: 4 },
-            tokens: { output: 12 },
-            providerID: "openai",
-            modelID: "gpt-5",
+        } as never,
+      });
+      await flushPromises();
+
+      assertEquals(state.contextLimit, 200_000);
+
+      await handler({
+        event: {
+          type: "message.updated",
+          properties: {
+            info: {
+              id: "m2",
+              sessionID: "session-1",
+              role: "assistant",
+              time: { created: 3, completed: 4 },
+              tokens: { output: 12 },
+              providerID: "openai",
+              modelID: "gpt-5",
+            },
           },
-        },
-      } as never,
-    });
-    await flushPromises();
-
-    assertEquals(providerCalls, 1);
-    assertEquals(state.contextLimit, 200_000);
+        } as never,
+      });
+      await flushPromises();
+
+      assertEquals(providerCalls, 1);
+      assertEquals(state.contextLimit, 200_000);
+    } finally {
+      setLoggerSilentOverride(false);
+    }
   });
 
   it("caches unknown provider/model misses to avoid repeated lookups", async () => {

src/services/graphiti-mcp.test.ts

@@ -2,6 +2,7 @@ import { assertEquals, assertRejects } from "jsr:@std/assert@^1.0.0";
 import { describe, it } from "jsr:@std/testing@^1.0.0/bdd";
 import { GraphitiOfflineError } from "./connection-manager.ts";
 import { GraphitiMcpClient } from "./graphiti-mcp.ts";
+import { setLoggerSilentOverride } from "./logger.ts";
 import {
   setOpenCodeClient,
   setSuppressConsoleWarningsDuringTestsOverride,
@@ -44,23 +45,28 @@ describe("GraphitiMcpClient", () => {
   });
 
   it("marks unexpected search node failures as degraded", async () => {
-    const client = new GraphitiMcpClient({
-      start() {},
-      stop() {
-        return Promise.resolve();
-      },
-      ready() {
-        return Promise.resolve(true);
-      },
-      callTool() {
-        return Promise.reject(new Error("boom"));
-      },
-    });
+    try {
+      setLoggerSilentOverride(true);
+      const client = new GraphitiMcpClient({
+        start() {},
+        stop() {
+          return Promise.resolve();
+        },
+        ready() {
+          return Promise.resolve(true);
+        },
+        callTool() {
+          return Promise.reject(new Error("boom"));
+        },
+      });
 
-    assertEquals(await client.searchNodesWithStatus({ query: "test" }), {
-      nodes: [],
-      degraded: true,
-    });
+      assertEquals(await client.searchNodesWithStatus({ query: "test" }), {
+        nodes: [],
+        degraded: true,
+      });
+    } finally {
+      setLoggerSilentOverride(false);
+    }
   });
 
   it("reports searchNodesWithStatus availability warnings with the correct operation name", async () => {

src/services/hot-tier-slice.test.ts

@@ -1315,7 +1315,7 @@ describe("hot-tier vertical slice", () => {
     }]);
   });
 
-  it("recovers a stuck same-group drain with one bounded recovery timer", async () => {
+  it("keeps one bounded recovery timer for a stuck same-group drain", async () => {
     const redis = new RedisClient({ endpoint: "redis://unused" });
     const redisCache = new RedisCacheService(redis, {
       ttlSeconds: 300,
@@ -1331,8 +1331,7 @@ describe("hot-tier vertical slice", () => {
 
     const neverSettles = new Promise<never>(() => {});
     const drainCalls: string[] = [];
-    const refreshCalls: Array<{ groupId: string; query: string }> = [];
-    let callCount = 0;
+    const warnSpy = spy(logger, "warn");
     const graphitiAsync = new GraphitiAsyncService(
       {
         getEpisodes() {
@@ -1341,55 +1340,57 @@ describe("hot-tier vertical slice", () => {
         searchMemoryFacts() {
           return Promise.resolve([]);
         },
-        searchNodesWithStatus(input: { query: string; groupIds: string[] }) {
-          refreshCalls.push({ groupId: input.groupIds[0], query: input.query });
+        searchNodesWithStatus() {
           return Promise.resolve({ nodes: [], degraded: false });
         },
       } as never,
       redisCache,
       {
         drainGroup(groupId: string) {
           drainCalls.push(groupId);
-          callCount += 1;
-          if (callCount === 1) return neverSettles;
-          if (callCount === 2) {
-            return Promise.resolve({ status: "success" as const, drained: 1 });
-          }
-          return Promise.resolve({ status: "empty" as const, drained: 0 });
+          return neverSettles;
         },
       } as never,
       1,
+      1,
     );
 
-    const drainRecoveryTimers = (
-      graphitiAsync as unknown as {
-        drainRecoveryTimers: Map<
-          string,
-          { run: Promise<void>; timer: ReturnType<typeof setTimeout> }
-        >;
-      }
-    ).drainRecoveryTimers;
+    try {
+      const drainRecoveryTimers = (
+        graphitiAsync as unknown as {
+          drainRecoveryTimers: Map<
+            string,
+            { run: Promise<void>; timer: ReturnType<typeof setTimeout> }
+          >;
+        }
+      ).drainRecoveryTimers;
 
-    graphitiAsync.scheduleDrain("group-1");
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    graphitiAsync.scheduleDrain("group-1");
-    graphitiAsync.scheduleDrain("group-1");
+      graphitiAsync.scheduleDrain("group-1");
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      graphitiAsync.scheduleDrain("group-1");
+      graphitiAsync.scheduleDrain("group-1");
 
-    assertEquals(drainRecoveryTimers.size, 1);
+      assertEquals(drainRecoveryTimers.size, 1);
 
-    await waitFor(() => drainCalls.length === 3);
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    await new Promise((resolve) => setTimeout(resolve, 0));
+      await waitFor(() => warnSpy.calls.length === 1);
+      await new Promise((resolve) => setTimeout(resolve, 0));
 
-    assertEquals(drainCalls, ["group-1", "group-1", "group-1"]);
-    assertEquals(refreshCalls, [{
-      groupId: "group-1",
-      query: "cached query",
-    }]);
-    assertEquals(drainRecoveryTimers.size, 0);
+      assertEquals(drainCalls, ["group-1"]);
+      assertEquals(
+        warnSpy.calls[0].args[0],
+        "Graphiti drain recovery timeout exceeded; leaving in-flight drain intact",
+      );
+      assertEquals(warnSpy.calls[0].args[1], {
+        groupId: "group-1",
+        timeoutMs: 1,
+      });
+      assertEquals(drainRecoveryTimers.size, 0);
+    } finally {
+      warnSpy.restore();
+    }
   });
 
-  it("recovers a stuck drain even without a duplicate schedule signal", async () => {
+  it("warns on a stuck drain even without a duplicate schedule signal", async () => {
     const redis = new RedisClient({ endpoint: "redis://unused" });
     const redisCache = new RedisCacheService(redis, {
       ttlSeconds: 300,
@@ -1405,8 +1406,7 @@ describe("hot-tier vertical slice", () => {
 
     const neverSettles = new Promise<never>(() => {});
     const drainCalls: string[] = [];
-    const refreshCalls: Array<{ groupId: string; query: string }> = [];
-    let callCount = 0;
+    const warnSpy = spy(logger, "warn");
     const graphitiAsync = new GraphitiAsyncService(
       {
         getEpisodes() {
@@ -1415,37 +1415,39 @@ describe("hot-tier vertical slice", () => {
         searchMemoryFacts() {
           return Promise.resolve([]);
         },
-        searchNodesWithStatus(input: { query: string; groupIds: string[] }) {
-          refreshCalls.push({ groupId: input.groupIds[0], query: input.query });
+        searchNodesWithStatus() {
           return Promise.resolve({ nodes: [], degraded: false });
         },
       } as never,
       redisCache,
       {
         drainGroup(groupId: string) {
           drainCalls.push(groupId);
-          callCount += 1;
-          if (callCount === 1) return neverSettles;
-          if (callCount === 2) {
-            return Promise.resolve({ status: "success" as const, drained: 1 });
-          }
-          return Promise.resolve({ status: "empty" as const, drained: 0 });
+          return neverSettles;
         },
       } as never,
       1,
+      1,
     );
 
-    graphitiAsync.scheduleDrain("group-1");
+    try {
+      graphitiAsync.scheduleDrain("group-1");
 
-    await waitFor(() => drainCalls.length === 3);
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    await new Promise((resolve) => setTimeout(resolve, 0));
+      await waitFor(() => warnSpy.calls.length === 1);
+      await new Promise((resolve) => setTimeout(resolve, 0));
 
-    assertEquals(drainCalls, ["group-1", "group-1", "group-1"]);
-    assertEquals(refreshCalls, [{
-      groupId: "group-1",
-      query: "cached query",
-    }]);
+      assertEquals(drainCalls, ["group-1"]);
+      assertEquals(
+        warnSpy.calls[0].args[0],
+        "Graphiti drain recovery timeout exceeded; leaving in-flight drain intact",
+      );
+      assertEquals(warnSpy.calls[0].args[1], {
+        groupId: "group-1",
+        timeoutMs: 1,
+      });
+    } finally {
+      warnSpy.restore();
+    }
   });
 
   it("preserves warm cache entry when refresh degrades during node search", async () => {