DEV test update

Author: cdcabrera

src/__tests__/__snapshots__/server.toolsHostCreator.test.ts.snap

@@ -0,0 +1,12 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`resolveExternalCreators should return a normalized module output with expected properties: normalized 1`] = `
+[
+  "Tool1",
+  {
+    "description": "Tool 1",
+    "inputSchema": "[object Object] isZod = true",
+  },
+  [MockFunction],
+]
+`;

src/__tests__/server.toolsHostCreator.test.ts

@@ -1,138 +1,155 @@
+import { z } from 'zod';
 import { resolveExternalCreators } from '../server.toolsHostCreator';
-import { type McpToolCreator } from '../server';
+import { isZodSchema } from '../server.schema';
 
-// Mock dependencies
-jest.mock('../logger', () => ({
-  log: {
-    warn: jest.fn(),
-    error: jest.fn(),
-    info: jest.fn(),
-    debug: jest.fn()
-  },
-  formatUnknownError: jest.fn((error: unknown) => String(error))
-}));
-
-// plugin-object support removed in streamlined implementation
-
-// plugin-object adapters removed; tests eliminated
-
-describe('resolveExternalCreators (streamlined)', () => {
+describe('resolveExternalCreators', () => {
   it.each([
     {
-      description: 'function export returning a realized tuple (cached)',
-      moduleExports: { default: () => ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()] },
-      expectedLength: 1
-    },
-    {
-      description: 'tool creator as default export',
+      description: 'valid format, default export with function, tuple',
       moduleExports: {
         default: () => ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()]
       },
-      expectedLength: 1
+      isValid: true
     },
     {
-      description: 'array of tool creators',
-      moduleExports: [
-        () => ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()],
-        () => ['Tool2', { description: 'Tool 2', inputSchema: {} }, jest.fn()]
-      ],
-      expectedLength: 2
+      description: 'valid format, default export with function, array of functions with tuple return',
+      moduleExports: {
+        default: () => [
+          () => ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()],
+          () => ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()]
+        ]
+      },
+      isValid: true
     },
     {
-      description: 'array of tool creators as default export',
+      description: 'valid format, default export with array of functions with tuple return',
       moduleExports: {
         default: [
+          () => ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()],
           () => ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()]
         ]
       },
-      expectedLength: 1
+      isValid: true
+    },
+    {
+      description: 'invalid format, default export with function, array of tuples',
+      moduleExports: {
+        default: () => [
+          ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()],
+          ['Tool2', { description: 'Tool 2', inputSchema: {} }, jest.fn()]
+        ]
+      },
+      isValid: false
+    },
+    {
+      description: 'invalid format, default export with tuple',
+      moduleExports: {
+        default: ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()]
+      },
+      isValid: false
+    },
+    {
+      description: 'invalid format, default export with array of tuples',
+      moduleExports: {
+        default: [
+          ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()],
+          ['Tool2', { description: 'Tool 2', inputSchema: {} }, jest.fn()]
+        ]
+      },
+      isValid: false
+    },
+    {
+      description: 'invalid format, default export function that returns empty',
+      moduleExports: {
+        default: () => {}
+      },
+      isValid: false
     },
     {
-      description: 'empty module',
+      description: 'invalid format, empty module',
       moduleExports: {},
-      expectedLength: 0
+      isValid: false
     },
     {
-      description: 'null',
+      description: 'invalid format, default export function that returns null',
+      moduleExports: {
+        default: () => null
+      },
+      isValid: false
+    },
+    {
+      description: 'invalid format, null',
       moduleExports: null,
-      expectedLength: 0
+      isValid: false
+    },
+    {
+      description: 'invalid format, default export function that returns undefined',
+      moduleExports: {
+        default: () => undefined
+      },
+      isValid: false
     },
     {
-      description: 'undefined',
+      description: 'invalid format, undefined',
       moduleExports: undefined,
-      expectedLength: 0
+      isValid: false
     },
     {
-      description: 'function that throws',
+      description: 'invalid format, default export function that throws',
+      moduleExports: {
+        default: () => {
+          throw new Error('Function error');
+        }
+      },
+      isValid: false
+    },
+    {
+      description: 'invalid format, function that throws',
       moduleExports: () => {
         throw new Error('Function error');
       },
-      expectedLength: 0
+      isValid: false
     },
     {
-      description: 'function returning unsupported shape',
+      description: 'invalid format, function returning unsupported shape',
       moduleExports: () => 'not a tool or creators[]',
-      expectedLength: 0
+      isValid: false
     },
     {
-      description: 'array with non-function elements',
+      description: 'invalid format, array with non-function elements',
       moduleExports: ['not a function', 123, {}],
-      expectedLength: 0
+      isValid: false
     },
     {
-      description: 'function returning non-tuple array (should not pass)',
-      moduleExports: () => ['not a tool tuple', 123],
-      expectedLength: 0
+      description: 'invalid format, named exports only',
+      moduleExports: {
+        named1: () => ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()],
+        named2: () => ['Tool2', { description: 'Tool 2', inputSchema: {} }, jest.fn()]
+      },
+      isValid: false
     }
-  ])('should normalize module exports, $description', ({ moduleExports, expectedLength }) => {
+  ])('should normalize module exports with specific formats, $description', ({ moduleExports, isValid }) => {
     const result = resolveExternalCreators(moduleExports);
 
     expect(Array.isArray(result)).toBe(true);
-    expect(result.length).toBe(expectedLength);
-    if (expectedLength > 0) {
-      expect(typeof result[0]).toBe('function');
-    }
-  });
-
-  it('should handle multiple candidates (default and named)', () => {
-    const defaultTuple = ['Tool1', { description: 'Tool 1', inputSchema: {} }, jest.fn()] as const;
-    const moduleExports = {
-      default: () => defaultTuple,
-      named: 'not a creator'
-    } as any;
-
-    const result = resolveExternalCreators(moduleExports);
-
-    // Should use default export and wrap cached tuple
-    expect(result.length).toBe(1);
-    expect(typeof result[0]).toBe('function');
-    expect((result[0] as any).toolName).toBe('Tool1');
-    expect(result[0]!()).toBe(defaultTuple);
-  });
-
-  it('should prefer default export over named export', () => {
-    const defaultTuple = ['DefaultTool', { description: 'Default', inputSchema: {} }, jest.fn()] as const;
-    const namedCreator: McpToolCreator = () => ['NamedTool', { description: 'Named', inputSchema: {} }, jest.fn()];
-
-    const moduleExports = {
-      default: () => defaultTuple,
-      named: namedCreator
-    } as any;
-
-    const result = resolveExternalCreators(moduleExports);
-
-    expect(result.length).toBe(1);
-    expect(typeof result[0]).toBe('function');
-    expect(result[0]!()).toBe(defaultTuple);
+    expect(result.length > 0).toBe(isValid);
   });
 
-  it('should handle function export that throws during invocation', () => {
-    const moduleExports = () => {
-      throw new Error('Factory error');
+  it('should return a normalized module output with expected properties', () => {
+    const moduleExport = {
+      default: () => ['Tool1', { description: 'Tool 1', inputSchema: z.any() }, jest.fn()]
     };
 
-    const result = resolveExternalCreators(moduleExports);
+    const [result] = resolveExternalCreators(moduleExport);
+    const [name, schema = {}, handler]: any[] = result?.() || [];
 
-    expect(result.length).toBe(0);
+    expect([
+      name,
+      {
+        description: schema.description,
+        inputSchema: `${schema} isZod = ${isZodSchema(schema.inputSchema)}`
+      },
+      handler
+    ]).toMatchSnapshot('normalized');
   });
 });