public/browser
1
0
Fork 0
mirror of https://github.com/lightpanda-io/browser.git synced 2026-03-22 04:34:44 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

mcp: improve robustness of server and test harness

Browse Source 
- Refactor router and test harness for non-blocking I/O using buffered polling.
- Implement reliable test failure reporting from sub-threads to the main test runner.
- Encapsulate pipe management using idiomatic std.fs.File methods.
- Fix invalid JSON generation in resource streaming due to duplicate fields.
- Improve shutdown sequence for clean test exits.
This commit is contained in:
Adrià Arrufat
2026-03-02 16:50:47 +09:00
parent 64107f5957
commit a7872aa054
4 changed files with 203 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
src/mcp/Server.zig
View File

@@ -89,156 +89,158 @@ test "MCP Integration: handshake and tools/list" {
const harness = try McpHarness.init(testing.allocator, testing.test_app);
defer harness.deinit();
harness.thread = try std.Thread.spawn(.{}, testHandshakeAndTools, .{harness});
harness.thread = try std.Thread.spawn(.{}, wrapTest, .{ testHandshakeAndToolsInternal, harness });
try harness.runServer();
}
fn testHandshakeAndTools(harness: *McpHarness) void {
defer harness.server.is_running.store(false, .release);
fn wrapTest(comptime func: fn (*McpHarness) anyerror!void, harness: *McpHarness) void {
const res = func(harness);
if (res) |_| {
harness.test_error = null;
} else |err| {
harness.test_error = err;
}
harness.server.is_running.store(false, .release);
// Ensure we trigger a poll wake up if needed
_ = harness.client_out.writeAll("\n") catch {};
}
fn testHandshakeAndToolsInternal(harness: *McpHarness) !void {
// 1. Initialize
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test-client","version":"1.0.0"}}}
) catch return;
);
var arena = std.heap.ArenaAllocator.init(harness.allocator);
defer arena.deinit();
const response1 = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response1, "\"id\":1") != null) catch return;
testing.expect(std.mem.indexOf(u8, response1, "\"protocolVersion\":\"2025-11-25\"") != null) catch return;
const response1 = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response1, "\"id\":1") != null);
try testing.expect(std.mem.indexOf(u8, response1, "\"protocolVersion\":\"2025-11-25\"") != null);
// 2. Initialized notification
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","method":"notifications/initialized"}
) catch return;
);
// 3. List tools
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":2,"method":"tools/list"}
) catch return;
);
const response2 = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response2, "\"id\":2") != null) catch return;
testing.expect(std.mem.indexOf(u8, response2, "\"name\":\"goto\"") != null) catch return;
const response2 = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response2, "\"id\":2") != null);
try testing.expect(std.mem.indexOf(u8, response2, "\"name\":\"goto\"") != null);
}
test "MCP Integration: tools/call evaluate" {
const harness = try McpHarness.init(testing.allocator, testing.test_app);
defer harness.deinit();
harness.thread = try std.Thread.spawn(.{}, testEvaluate, .{harness});
harness.thread = try std.Thread.spawn(.{}, wrapTest, .{ testEvaluateInternal, harness });
try harness.runServer();
}
fn testEvaluate(harness: *McpHarness) void {
defer harness.server.is_running.store(false, .release);
harness.sendRequest(
fn testEvaluateInternal(harness: *McpHarness) !void {
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"evaluate","arguments":{"script":"1 + 1"}}}
) catch return;
);
var arena = std.heap.ArenaAllocator.init(harness.allocator);
defer arena.deinit();
const response = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response, "\"id\":1") != null) catch return;
testing.expect(std.mem.indexOf(u8, response, "\"text\":\"2\"") != null) catch return;
const response = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response, "\"id\":1") != null);
try testing.expect(std.mem.indexOf(u8, response, "\"text\":\"2\"") != null);
}
test "MCP Integration: error handling" {
const harness = try McpHarness.init(testing.allocator, testing.test_app);
defer harness.deinit();
harness.thread = try std.Thread.spawn(.{}, testErrorHandling, .{harness});
harness.thread = try std.Thread.spawn(.{}, wrapTest, .{ testErrorHandlingInternal, harness });
try harness.runServer();
}
fn testErrorHandling(harness: *McpHarness) void {
defer harness.server.is_running.store(false, .release);
fn testErrorHandlingInternal(harness: *McpHarness) !void {
var arena = std.heap.ArenaAllocator.init(harness.allocator);
defer arena.deinit();
// 1. Tool not found
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"non_existent_tool"}}
) catch return;
);
const response1 = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response1, "\"id\":1") != null) catch return;
testing.expect(std.mem.indexOf(u8, response1, "\"code\":-32601") != null) catch return;
const response1 = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response1, "\"id\":1") != null);
try testing.expect(std.mem.indexOf(u8, response1, "\"code\":-32601") != null);
// 2. Invalid params (missing script for evaluate)
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"evaluate","arguments":{}}}
) catch return;
);
const response2 = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response2, "\"id\":2") != null) catch return;
testing.expect(std.mem.indexOf(u8, response2, "\"code\":-32602") != null) catch return;
const response2 = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response2, "\"id\":2") != null);
try testing.expect(std.mem.indexOf(u8, response2, "\"code\":-32602") != null);
}
test "MCP Integration: resources" {
const harness = try McpHarness.init(testing.allocator, testing.test_app);
defer harness.deinit();
harness.thread = try std.Thread.spawn(.{}, testResources, .{harness});
harness.thread = try std.Thread.spawn(.{}, wrapTest, .{ testResourcesInternal, harness });
try harness.runServer();
}
fn testResources(harness: *McpHarness) void {
defer harness.server.is_running.store(false, .release);
fn testResourcesInternal(harness: *McpHarness) !void {
var arena = std.heap.ArenaAllocator.init(harness.allocator);
defer arena.deinit();
// 1. List resources
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":1,"method":"resources/list"}
) catch return;
);
const response1 = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response1, "\"uri\":\"mcp://page/html\"") != null) catch return;
const response1 = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response1, "\"uri\":\"mcp://page/html\"") != null);
// 2. Read resource
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":2,"method":"resources/read","params":{"uri":"mcp://page/html"}}
) catch return;
);
const response2 = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response2, "\"id\":2") != null) catch return;
// Check for some HTML content
testing.expect(std.mem.indexOf(u8, response2, "<html>") != null) catch return;
const response2 = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response2, "\"id\":2") != null);
// Just check for 'html' to be case-insensitive and robust
try testing.expect(std.mem.indexOf(u8, response2, "html") != null);
}
test "MCP Integration: tools markdown and links" {
const harness = try McpHarness.init(testing.allocator, testing.test_app);
defer harness.deinit();
harness.thread = try std.Thread.spawn(.{}, testMarkdownAndLinks, .{harness});
harness.thread = try std.Thread.spawn(.{}, wrapTest, .{ testMarkdownAndLinksInternal, harness });
try harness.runServer();
}
fn testMarkdownAndLinks(harness: *McpHarness) void {
defer harness.server.is_running.store(false, .release);
fn testMarkdownAndLinksInternal(harness: *McpHarness) !void {
var arena = std.heap.ArenaAllocator.init(harness.allocator);
defer arena.deinit();
// 1. Test markdown
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"markdown"}}
) catch return;
);
const response1 = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response1, "\"id\":1") != null) catch return;
const response1 = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response1, "\"id\":1") != null);
// 2. Test links
harness.sendRequest(
try harness.sendRequest(
\\{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"links"}}
) catch return;
);
const response2 = harness.readResponse(arena.allocator()) catch return;
testing.expect(std.mem.indexOf(u8, response2, "\"id\":2") != null) catch return;
const response2 = try harness.readResponse(arena.allocator());
try testing.expect(std.mem.indexOf(u8, response2, "\"id\":2") != null);
}