Testing the group/tag changes

In src/client/filtering.test.ts
* Tests client-side filtering capabilities
* Verifies listGroups and listTags methods work correctly
* Tests filtering tools by groups, tags, and combinations
* Verifies error handling when filtering capability is not available

In src/server/filtering.test.ts
* Tests server-side filtering capabilities
* Verifies group and tag registration, updating, and removal
* Tests filtering tools by groups, tags, and combinations
* Verifies that tools match ANY of the specified groups
* Verifies that tools match ALL of the specified tags

In src/integration-tests/filtering.test.ts
* End-to-end tests for filtering capabilities
* Tests listing groups and tags
* Tests filtering tools by groups, tags, and combinations
* Verifies correct behavior with real HTTP server and transports

Author: cliffhall

src/client/filtering.test.ts

@@ -0,0 +1,253 @@
+import { Client } from "./index.js";
+import { MockTransport } from "./mockTransport.js";
+import {
+  Group,
+  Tag,
+  Tool,
+  ToolsFilter,
+} from "../types.js";
+
+describe("Client filtering capabilities", () => {
+  let client: Client;
+  let transport: MockTransport;
+
+  beforeEach(() => {
+    transport = new MockTransport();
+    client = new Client({ name: "test-client", version: "1.0.0" });
+    client.connect(transport);
+
+    // Mock server capabilities to include filtering
+    transport.mockServerCapabilities({
+      filtering: {
+        groups: {
+          listChanged: true
+        },
+        tags: {
+          listChanged: true
+        }
+      }
+    });
+
+    // Client is already connected and ready to use
+  });
+
+  describe("listGroups", () => {
+    test("should request groups from the server", async () => {
+      // Mock server response
+      const mockGroups: Group[] = [
+        {
+          name: "user",
+          title: "User Management Tools",
+          description: "Tools used for managing user accounts within the system."
+        },
+        {
+          name: "mapping",
+          title: "Geospatial Mapping Tools",
+          description: "Tools used for map rendering, geocoding, and spatial analysis."
+        }
+      ];
+
+      transport.mockResponse(
+        { method: "groups/list" },
+        { groups: mockGroups }
+      );
+
+      // Call the method
+      const result = await client.listGroups();
+
+      // Verify the request was made correctly
+      expect(transport.lastRequest).toEqual({
+        jsonrpc: "2.0",
+        method: "groups/list",
+        params: {},
+        id: expect.anything()
+      });
+
+      // Verify the response was parsed correctly
+      expect(result).toEqual({ groups: mockGroups });
+    });
+
+    test("should throw an error if filtering capability is not available", async () => {
+      // Create a new client without filtering capability
+      const newTransport = new MockTransport();
+      const newClient = new Client({ name: "test-client", version: "1.0.0" });
+      newClient.connect(newTransport);
+
+      // Mock server capabilities without filtering
+      newTransport.mockServerCapabilities({});
+
+      // Expect the method to throw an error
+      await expect(newClient.listGroups()).rejects.toThrow(
+        "Server does not support method: groups/list"
+      );
+    }, 10000); // Increase timeout to 10 seconds
+  });
+
+  describe("listTags", () => {
+    test("should request tags from the server", async () => {
+      // Mock server response
+      const mockTags: Tag[] = [
+        {
+          name: "beta",
+          description: "Experimental or in-testing tools"
+        },
+        {
+          name: "stable",
+          description: "Production-ready tools."
+        }
+      ];
+
+      transport.mockResponse(
+        { method: "tags/list" },
+        { tags: mockTags }
+      );
+
+      // Call the method
+      const result = await client.listTags();
+
+      // Verify the request was made correctly
+      expect(transport.lastRequest).toEqual({
+        jsonrpc: "2.0",
+        method: "tags/list",
+        params: {},
+        id: expect.anything()
+      });
+
+      // Verify the response was parsed correctly
+      expect(result).toEqual({ tags: mockTags });
+    });
+
+    test("should throw an error if filtering capability is not available", async () => {
+      // Create a new client without filtering capability
+      const newTransport = new MockTransport();
+      const newClient = new Client({ name: "test-client", version: "1.0.0" });
+      newClient.connect(newTransport);
+
+      // Mock server capabilities without filtering
+      newTransport.mockServerCapabilities({});
+
+      // Expect the method to throw an error
+      await expect(newClient.listTags()).rejects.toThrow(
+        "Server does not support method: tags/list"
+      );
+    }, 10000); // Increase timeout to 10 seconds
+  });
+
+  describe("listTools with filtering", () => {
+    test("should request tools with group filter", async () => {
+      // Mock tools
+      const mockTools: Tool[] = [
+        {
+          name: "user_create",
+          title: "Create User",
+          description: "Creates a new user account",
+          inputSchema: { type: "object", properties: {} },
+          groups: ["user"]
+        }
+      ];
+
+      // Set up the mock response
+      transport.mockResponse(
+        { method: "tools/list" },
+        { tools: mockTools }
+      );
+
+      // Create filter
+      const filter: ToolsFilter = {
+        groups: ["user"]
+      };
+
+      // Call the method with filter
+      const result = await client.listTools({ filter });
+
+      // Verify the request was made correctly
+      expect(transport.lastRequest).toEqual({
+        jsonrpc: "2.0",
+        method: "tools/list",
+        params: { filter },
+        id: expect.anything()
+      });
+
+      // Verify the response was parsed correctly
+      expect(result).toEqual({ tools: mockTools });
+    });
+
+    test("should request tools with tag filter", async () => {
+      // Mock tools
+      const mockTools: Tool[] = [
+        {
+          name: "map_render",
+          title: "Render Map",
+          description: "Renders a map with the given parameters",
+          inputSchema: { type: "object", properties: {} },
+          tags: ["stable"]
+        }
+      ];
+
+      // Set up the mock response
+      transport.mockResponse(
+        { method: "tools/list" },
+        { tools: mockTools }
+      );
+
+      // Create filter
+      const filter: ToolsFilter = {
+        tags: ["stable"]
+      };
+
+      // Call the method with filter
+      const result = await client.listTools({ filter });
+
+      // Verify the request was made correctly
+      expect(transport.lastRequest).toEqual({
+        jsonrpc: "2.0",
+        method: "tools/list",
+        params: { filter },
+        id: expect.anything()
+      });
+
+      // Verify the response was parsed correctly
+      expect(result).toEqual({ tools: mockTools });
+    });
+
+    test("should request tools with both group and tag filters", async () => {
+      // Mock tools
+      const mockTools: Tool[] = [
+        {
+          name: "user_delete",
+          title: "Delete User",
+          description: "Deletes a user account",
+          inputSchema: { type: "object", properties: {} },
+          groups: ["user"],
+          tags: ["destructive"]
+        }
+      ];
+
+      // Set up the mock response
+      transport.mockResponse(
+        { method: "tools/list" },
+        { tools: mockTools }
+      );
+
+      // Create filter
+      const filter: ToolsFilter = {
+        groups: ["user"],
+        tags: ["destructive"]
+      };
+
+      // Call the method with filter
+      const result = await client.listTools({ filter });
+
+      // Verify the request was made correctly
+      expect(transport.lastRequest).toEqual({
+        jsonrpc: "2.0",
+        method: "tools/list",
+        params: { filter },
+        id: expect.anything()
+      });
+
+      // Verify the response was parsed correctly
+      expect(result).toEqual({ tools: mockTools });
+    });
+  });
+});

src/client/mockTransport.ts

@@ -0,0 +1,121 @@
+import { Transport } from "../shared/transport.js";
+import { JSONRPCMessage, RequestId, ServerCapabilities } from "../types.js";
+import { AuthInfo } from "../server/auth/types.js";
+
+/**
+ * Mock transport for testing client functionality.
+ * This implements the Transport interface and adds methods for mocking server responses.
+ */
+export class MockTransport implements Transport {
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage, extra?: { authInfo?: AuthInfo }) => void;
+  sessionId?: string;
+
+  private _serverCapabilities: ServerCapabilities = {};
+  lastRequest?: JSONRPCMessage;
+
+  /**
+   * Mocks the server capabilities that would be returned during initialization.
+   */
+  mockServerCapabilities(capabilities: ServerCapabilities): void {
+    this._serverCapabilities = capabilities;
+  }
+
+  /**
+   * Mocks a response from the server for a specific request.
+   * @param request Object containing method and optional params to match
+   * @param response The response to return when the request matches
+   */
+  mockResponse(
+    request: { method: string; params?: Record<string, unknown> },
+    response: Record<string, unknown>
+  ): void {
+    const key = this.getRequestKey(request);
+    this._responseMap.set(key, response);
+  }
+
+  private getRequestKey(request: { method: string; params?: Record<string, unknown> }): string {
+    if (!request.params) {
+      return request.method;
+    }
+    // Create a unique key based on method and params
+    return `${request.method}:${JSON.stringify(request.params)}`;
+  }
+
+  private _responseMap = new Map<string, Record<string, unknown>>();
+
+  async start(): Promise<void> {
+    // No-op for mock
+  }
+
+  async close(): Promise<void> {
+    this.onclose?.();
+  }
+
+  async send(message: JSONRPCMessage, _options?: { relatedRequestId?: RequestId, authInfo?: AuthInfo }): Promise<void> {
+    // Store the last request for assertions
+    this.lastRequest = message;
+
+    // Check if this is a request message (has method and id)
+    if ('method' in message && 'id' in message) {
+      // Handle initialize request specially
+      if (message.method === "initialize") {
+        this.onmessage?.({
+          jsonrpc: "2.0",
+          id: message.id,
+          result: {
+            protocolVersion: "2024-10-07",
+            capabilities: this._serverCapabilities,
+            serverInfo: {
+              name: "mock-server",
+              version: "1.0.0",
+            },
+          },
+        });
+        return;
+      }
+
+      // Check if the method requires a capability that's not available
+      if ((message.method === "groups/list" || message.method === "tags/list") &&
+          (!this._serverCapabilities.filtering)) {
+        // Return an error for unsupported method
+        this.onmessage?.({
+          jsonrpc: "2.0",
+          id: message.id,
+          error: {
+            code: -32601,
+            message: `Server does not support method: ${message.method}`
+          }
+        });
+        return;
+      }
+
+      // For other requests, check if we have a mocked response
+      // First try to match with params
+      const requestWithParams = {
+        method: message.method,
+        params: 'params' in message ? message.params as Record<string, unknown> : undefined
+      };
+      const key = this.getRequestKey(requestWithParams);
+
+      if (this._responseMap.has(key)) {
+        const response = this._responseMap.get(key);
+        this.onmessage?.({
+          jsonrpc: "2.0",
+          id: message.id,
+          result: response || {},
+        });
+      }
+      // Fall back to method-only match if no match with params
+      else if (this._responseMap.has(message.method)) {
+        const response = this._responseMap.get(message.method);
+        this.onmessage?.({
+          jsonrpc: "2.0",
+          id: message.id,
+          result: response || {},
+        });
+      }
+    }
+  }
+}