add log utility tests

Author: KKonstantinov

src/server/mcp.test.ts

@@ -14,7 +14,8 @@ import {
     LoggingMessageNotificationSchema,
     Notification,
     TextContent,
-    ElicitRequestSchema
+    ElicitRequestSchema,
+    SetLevelRequestSchema
 } from '../types.js';
 import { ResourceTemplate } from './mcp.js';
 import { completable } from './completable.js';
@@ -319,6 +320,62 @@ describe('Context', () => {
         expect(parsed.userId).toBe('user-123');
         expect(parsed.attempt).toBe(1);
     });
+
+    const logLevelsThroughContext = ['debug', 'info', 'warning', 'error'] as const;
+
+    //it.each for each log level, test that logging message is sent to client
+    it.each(logLevelsThroughContext)('should send logging message to client for %s level from Context', async (level) => {
+        const mcpServer = new McpServer({ name: 'ctx-test', version: '1.0' }, {
+            capabilities: {
+                logging: {}
+            }
+        });
+        const client = new Client({ name: 'ctx-client', version: '1.0' }, {
+            capabilities: {
+                logging: {}
+            }
+        });
+
+        let seen = 0;
+
+        client.setNotificationHandler(LoggingMessageNotificationSchema, (notification) => {
+            seen++;
+            expect(notification.params.level).toBe(level);
+            expect(notification.params.data).toBe('Test message');
+            expect(notification.params.test).toBe('test');
+            expect(notification.params.sessionId).toBe('sample-session-id');
+            return;
+        });
+
+
+        mcpServer.tool('ctx-log-test', { name: z.string() }, async (_args: { name: string }, extra) => {
+            await extra[level]('Test message', { test: 'test' }, 'sample-session-id');
+            await extra.log({
+                level,
+                data: 'Test message',
+                logger: 'test-logger-namespace'
+            }, 'sample-session-id');
+            return { content: [{ type: 'text', text: 'ok' }] };
+        });
+
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        await Promise.all([client.connect(clientTransport), mcpServer.server.connect(serverTransport)]);
+        
+        const result = await client.request(
+            {
+                method: 'tools/call',
+                params: { name: 'ctx-log-test', arguments: { name: 'ctx-log-test-name' } }
+            },
+            CallToolResultSchema
+        );
+
+        // two messages should have been sent - one from the .log method and one from the .debug/info/warning/error method
+        expect(seen).toBe(2);
+
+        expect(result.content).toHaveLength(1);
+        expect(result.content[0].type).toBe('text');
+        expect(result.content[0].text).toBe('ok');
+    });
 });
 
 describe('ResourceTemplate', () => {
@@ -4132,6 +4189,115 @@ describe('elicitInput()', () => {
         );
     });
 
+    test('should be able to call elicit from Context', async () => {
+        mcpServer.tool(
+            'elicit-through-ctx-tool',
+            {
+                restaurant: z.string(),
+                date: z.string(),
+                partySize: z.number()
+            },
+            async ({ restaurant, date, partySize }, extra) => {
+                // Check availability
+                const available = await checkAvailability(restaurant, date, partySize);
+
+                if (!available) {
+                    // Ask user if they want to try alternative dates
+                    const result = await extra.elicit({
+                        message: `No tables available at ${restaurant} on ${date}. Would you like to check alternative dates?`,
+                        requestedSchema: {
+                            type: 'object',
+                            properties: {
+                                checkAlternatives: {
+                                    type: 'boolean',
+                                    title: 'Check alternative dates',
+                                    description: 'Would you like me to check other dates?'
+                                },
+                                flexibleDates: {
+                                    type: 'string',
+                                    title: 'Date flexibility',
+                                    description: 'How flexible are your dates?',
+                                    enum: ['next_day', 'same_week', 'next_week'],
+                                    enumNames: ['Next day', 'Same week', 'Next week']
+                                }
+                            },
+                            required: ['checkAlternatives']
+                        }
+                    });
+
+                    if (result.action === 'accept' && result.content?.checkAlternatives) {
+                        const alternatives = await findAlternatives(restaurant, date, partySize, result.content.flexibleDates as string);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Found these alternatives: ${alternatives.join(', ')}`
+                                }
+                            ]
+                        };
+                    }
+
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'No booking made. Original date not available.'
+                            }
+                        ]
+                    };
+                }
+
+                await makeBooking(restaurant, date, partySize);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Booked table for ${partySize} at ${restaurant} on ${date}`
+                        }
+                    ]
+                };
+            }
+        );
+
+        checkAvailability.mockResolvedValue(false);
+        findAlternatives.mockResolvedValue(['2024-12-26', '2024-12-27', '2024-12-28']);
+
+        // Set up client to accept alternative date checking
+        client.setRequestHandler(ElicitRequestSchema, async request => {
+            expect(request.params.message).toContain('No tables available at ABC Restaurant on 2024-12-25');
+            return {
+                action: 'accept',
+                content: {
+                    checkAlternatives: true,
+                    flexibleDates: 'same_week'
+                }
+            };
+        });
+
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+        await Promise.all([client.connect(clientTransport), mcpServer.server.connect(serverTransport)]);
+
+        // Call the tool
+        const result = await client.callTool({
+            name: 'book-restaurant',
+            arguments: {
+                restaurant: 'ABC Restaurant',
+                date: '2024-12-25',
+                partySize: 2
+            }
+        });
+
+        expect(checkAvailability).toHaveBeenCalledWith('ABC Restaurant', '2024-12-25', 2);
+        expect(findAlternatives).toHaveBeenCalledWith('ABC Restaurant', '2024-12-25', 2, 'same_week');
+        expect(result.content).toEqual([
+            {
+                type: 'text',
+                text: 'Found these alternatives: 2024-12-26, 2024-12-27, 2024-12-28'
+            }
+        ]);
+    });
+
     test('should successfully elicit additional information', async () => {
         // Mock availability check to return false
         checkAvailability.mockResolvedValue(false);