From 2efe8ad418e668b7cbe559a65901e4921fc6fabe Mon Sep 17 00:00:00 2001
From: lintianle <lintianle@deepseek.com>
Date: Wed, 8 Jul 2026 12:18:59 +0800
Subject: [PATCH] test: cover resync coalescing, onclose, and error path in
 mcp-client

Addresses CI coverage gap: exercises the latest-wins resync coalescing
(pendingResync branch), the client.onclose callback, and ensures index.ts
is loaded without module mocks for stable v8 coverage across environments.
---
 packages/mcp/mcp-client/tests/apply.spec.ts   | 51 +++++++++++++++++++
 .../mcp/mcp-client/tests/mcp-client.spec.ts   | 36 ++++++++++++-
 2 files changed, 86 insertions(+), 1 deletion(-)

diff --git a/packages/mcp/mcp-client/tests/apply.spec.ts b/packages/mcp/mcp-client/tests/apply.spec.ts
index 077cb4e3f6..baf1a4985c 100644
--- a/packages/mcp/mcp-client/tests/apply.spec.ts
+++ b/packages/mcp/mcp-client/tests/apply.spec.ts
@@ -22,6 +22,7 @@ class MockClient {
   listTools = mockListTools
   callTool = mockCallTool
   setNotificationHandler = mockSetNotificationHandler
+  onclose: (() => void) | null = null
 }
 
 vi.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
@@ -176,4 +177,54 @@ describe('apply (plugin lifecycle)', () => {
     expect(mockConnect).toHaveBeenCalled()
     expect(ctx.tools.get('remote')).toBeDefined()
   })
+
+  it('coalesces overlapping resync notifications (latest-wins)', async () => {
+    apply(ctx, stdioConfig)
+    await new Promise(r => setTimeout(r, 50))
+
+    // Initial sync is done; notification handler is registered.
+    const handler = mockSetNotificationHandler.mock.calls[0]![1] as () => Promise<void>
+
+    // Make the NEXT listTools call slow so we can trigger a second notification.
+    let resolveBlocked!: (v: unknown) => void
+    mockListTools.mockReturnValueOnce(new Promise((r) => { resolveBlocked = r }))
+
+    // Fire first notification — starts a resync that blocks on listTools.
+    const firstResync = handler()
+
+    // Fire second notification while the first is in-flight — should coalesce.
+    const secondResync = handler()
+
+    // Resolve the blocked listTools call.
+    resolveBlocked({ tools: [{ name: 'mid', inputSchema: { type: 'object' } }], nextCursor: undefined })
+
+    // Set up the response for the deferred resync that fires after the first completes.
+    mockListTools.mockResolvedValueOnce({
+      tools: [{ name: 'final', inputSchema: { type: 'object' } }],
+      nextCursor: undefined,
+    })
+
+    await firstResync
+    await secondResync
+    await new Promise(r => setTimeout(r, 50))
+
+    // The deferred resync should have run with the latest tool list.
+    expect(ctx.tools.get('final')).toBeDefined()
+  })
+
+  it('unregisters tools when the server connection closes (onclose)', async () => {
+    apply(ctx, stdioConfig)
+    await new Promise(r => setTimeout(r, 50))
+
+    expect(ctx.tools.get('remote')).toBeDefined()
+
+    // Simulate the MCP client's onclose firing (server crashed or closed).
+    // The apply() sets `client.onclose = () => {...}` on the mock instance.
+    // mockConnect receives `this` as the client instance.
+    const clientInstance = mockConnect.mock.contexts[0] as MockClient
+    expect(clientInstance.onclose).toBeTypeOf('function')
+    clientInstance.onclose!()
+
+    expect(ctx.tools.get('remote')).toBeUndefined()
+  })
 })
diff --git a/packages/mcp/mcp-client/tests/mcp-client.spec.ts b/packages/mcp/mcp-client/tests/mcp-client.spec.ts
index e81369c0f0..5f5a9bf2f4 100644
--- a/packages/mcp/mcp-client/tests/mcp-client.spec.ts
+++ b/packages/mcp/mcp-client/tests/mcp-client.spec.ts
@@ -5,7 +5,7 @@ import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry from '@deepseek-ai/dsh-tools'
 import { syncTools, type ToolBridgeOptions } from '@deepseek-ai/dsh-mcp-client/src/tools.ts'
 import { createTransport } from '@deepseek-ai/dsh-mcp-client/src/transport.ts'
-import type { Config } from '@deepseek-ai/dsh-mcp-client'
+import { apply, name, inject, Config } from '@deepseek-ai/dsh-mcp-client/src/index.ts'
 
 // ---- Mock MCP Client ----
 
@@ -516,3 +516,37 @@ describe('tool execution — non-object args fallback', () => {
   })
 })
 
+describe('plugin module exports', () => {
+  it('exports name, inject, and Config schema', () => {
+    expect(name).toBe('mcp-client')
+    expect(inject).toEqual(['tools'])
+    expect(Config).toBeDefined()
+  })
+})
+
+describe('apply (error path, no mocks)', () => {
+  it('gracefully catches when the MCP server is unreachable', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SystemPrompt)
+    await ctx.plugin(ToolRegistry)
+
+    // Call apply with a command that will fail to spawn/connect.
+    // The .catch() inside apply logs the error and registers no tools.
+    apply(ctx, {
+      transport: 'stdio',
+      command: '___nonexistent_binary_that_will_fail___',
+      args: [],
+      env: {},
+      cwd: '',
+      toolPrefix: '',
+      toolCallTimeoutMs: 1000,
+    })
+
+    // Give the async connect + catch chain time to settle.
+    await new Promise(r => setTimeout(r, 200))
+
+    // No tools should be registered since connect failed.
+    expect(ctx.tools.get('anything')).toBeUndefined()
+  })
+})
+