@frontmcp/skills 1.0.0-beta.13 → 1.0.0-beta.14

package/catalog/frontmcp-testing/examples/test-cli-binary/js-bundle-import-test.md

@@ -0,0 +1,56 @@
+---
+name: js-bundle-import-test
+reference: test-cli-binary
+level: intermediate
+description: 'Verify that the compiled JS bundle can be imported and exports the expected modules after a `frontmcp build` step.'
+tags: [testing, cli, binary, js, bundle, import]
+features:
+  - 'Using dynamic `import()` to test that the built JS bundle is importable'
+  - 'Verifying the bundle has a default export (server class or factory)'
+  - 'Testing CommonJS `require()` compatibility to ensure the bundle works in CJS environments'
+  - 'Pointing to the `dist/` output directory where `frontmcp build` places artifacts'
+---
+
+# Testing JS Bundle Importability
+
+Verify that the compiled JS bundle can be imported and exports the expected modules after a `frontmcp build` step.
+
+## Code
+
+```typescript
+// src/__tests__/js-bundle.spec.ts
+import * as path from 'path';
+
+const DIST_DIR = path.resolve(__dirname, '../dist');
+
+describe('JS Bundle', () => {
+  it('should be importable as a CJS module', async () => {
+    const mod = await import(path.join(DIST_DIR, 'my-server.cjs.js'));
+    expect(mod).toBeDefined();
+  });
+
+  it('should export a default server module', async () => {
+    const mod = await import(path.join(DIST_DIR, 'my-server.cjs.js'));
+    // The default export should be the server class or factory
+    expect(mod.default || mod).toBeDefined();
+  });
+
+  it('should not throw on require', () => {
+    expect(() => {
+      require(path.join(DIST_DIR, 'my-server.cjs.js'));
+    }).not.toThrow();
+  });
+});
+```
+
+## What This Demonstrates
+
+- Using dynamic `import()` to test that the built JS bundle is importable
+- Verifying the bundle has a default export (server class or factory)
+- Testing CommonJS `require()` compatibility to ensure the bundle works in CJS environments
+- Pointing to the `dist/` output directory where `frontmcp build` places artifacts
+
+## Related
+
+- See `test-cli-binary` for the full CLI binary testing reference
+- See `test-browser-build` for browser-specific build testing

package/catalog/frontmcp-testing/examples/test-direct-client/basic-create-test.md

@@ -0,0 +1,74 @@
+---
+name: basic-create-test
+reference: test-direct-client
+level: basic
+description: 'Test tools in-memory without any HTTP overhead using the `create()` function from `@frontmcp/sdk`.'
+tags: [testing, sdk, transport, direct-client, direct, client]
+features:
+  - 'Using `create()` to spin up an in-memory server with no HTTP transport'
+  - 'Defining tools inline with the functional `tool()` API and Zod schemas'
+  - 'Calling tools directly via `server.callTool()` and checking text content'
+  - 'Proper cleanup with `server.dispose()` in each test'
+---
+
+# Basic In-Memory Testing with create()
+
+Test tools in-memory without any HTTP overhead using the `create()` function from `@frontmcp/sdk`.
+
+## Code
+
+```typescript
+// src/__tests__/direct-client.spec.ts
+import { create } from '@frontmcp/sdk';
+import { tool } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+const AddTool = tool({
+  name: 'add',
+  description: 'Add numbers',
+  inputSchema: { a: z.number(), b: z.number() },
+  outputSchema: { sum: z.number() },
+})((input) => ({ sum: input.a + input.b }));
+
+describe('Direct Client Testing', () => {
+  it('should call tools via create()', async () => {
+    const server = await create({
+      info: { name: 'test', version: '1.0.0' },
+      tools: [AddTool],
+      cacheKey: 'test-direct',
+    });
+
+    const result = await server.callTool('add', { a: 2, b: 3 });
+    expect(result.content[0].text).toContain('5');
+
+    await server.dispose();
+  });
+
+  it('should handle multiple tool calls', async () => {
+    const server = await create({
+      info: { name: 'test', version: '1.0.0' },
+      tools: [AddTool],
+      cacheKey: 'test-direct-multi',
+    });
+
+    const r1 = await server.callTool('add', { a: 10, b: 20 });
+    expect(r1.content[0].text).toContain('30');
+
+    const r2 = await server.callTool('add', { a: -5, b: 5 });
+    expect(r2.content[0].text).toContain('0');
+
+    await server.dispose();
+  });
+});
+```
+
+## What This Demonstrates
+
+- Using `create()` to spin up an in-memory server with no HTTP transport
+- Defining tools inline with the functional `tool()` API and Zod schemas
+- Calling tools directly via `server.callTool()` and checking text content
+- Proper cleanup with `server.dispose()` in each test
+
+## Related
+
+- See `test-direct-client` for the full direct client testing reference

package/catalog/frontmcp-testing/examples/test-direct-client/openai-claude-format-test.md

@@ -0,0 +1,79 @@
+---
+name: openai-claude-format-test
+reference: test-direct-client
+level: intermediate
+description: 'Verify that tools are returned in the correct format for OpenAI and Claude clients using `connectOpenAI` and `connectClaude`.'
+tags: [testing, openai, anthropic, direct-client, direct, client]
+features:
+  - 'Using `connectOpenAI()` with `serve: false` to get an in-memory client without starting an HTTP server'
+  - "Verifying OpenAI tool format: `{ type: 'function', function: { name, parameters } }`"
+  - 'Using dynamic import for `connectClaude` to test Claude tool format: `{ name, description, input_schema }`'
+  - 'Proper cleanup with `client.close()` after each test'
+---
+
+# Testing OpenAI and Claude Tool Formats
+
+Verify that tools are returned in the correct format for OpenAI and Claude clients using `connectOpenAI` and `connectClaude`.
+
+## Code
+
+```typescript
+// src/__tests__/client-formats.spec.ts
+import { connectOpenAI } from '@frontmcp/sdk';
+import { tool } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+const AddTool = tool({
+  name: 'add',
+  description: 'Add numbers',
+  inputSchema: { a: z.number(), b: z.number() },
+  outputSchema: { sum: z.number() },
+})((input) => ({ sum: input.a + input.b }));
+
+describe('OpenAI format', () => {
+  it('should return OpenAI-formatted tools', async () => {
+    const client = await connectOpenAI({
+      info: { name: 'test', version: '1.0.0' },
+      tools: [AddTool],
+      serve: false,
+    });
+
+    const tools = await client.listTools();
+    // OpenAI format: [{ type: 'function', function: { name, parameters } }]
+    expect(tools[0].type).toBe('function');
+    expect(tools[0].function.name).toBe('add');
+    expect(tools[0].function.parameters).toBeDefined();
+
+    await client.close();
+  });
+});
+
+describe('Claude format', () => {
+  it('should return Claude-formatted tools', async () => {
+    const { connectClaude } = await import('@frontmcp/sdk');
+    const client = await connectClaude({
+      info: { name: 'test', version: '1.0.0' },
+      tools: [AddTool],
+      serve: false,
+    });
+
+    const tools = await client.listTools();
+    // Claude format: [{ name, description, input_schema }]
+    expect(tools[0].name).toBe('add');
+    expect(tools[0].input_schema).toBeDefined();
+
+    await client.close();
+  });
+});
+```
+
+## What This Demonstrates
+
+- Using `connectOpenAI()` with `serve: false` to get an in-memory client without starting an HTTP server
+- Verifying OpenAI tool format: `{ type: 'function', function: { name, parameters } }`
+- Using dynamic import for `connectClaude` to test Claude tool format: `{ name, description, input_schema }`
+- Proper cleanup with `client.close()` after each test
+
+## Related
+
+- See `test-direct-client` for the full direct client testing reference

package/catalog/frontmcp-testing/examples/test-e2e-handler/basic-e2e-test.md

@@ -0,0 +1,67 @@
+---
+name: basic-e2e-test
+reference: test-e2e-handler
+level: basic
+description: 'Set up a basic E2E test that starts a server, connects a client, and verifies tools are listed.'
+tags: [testing, e2e, handler]
+features:
+  - 'Using `TestServer.create()` to start a server from its module export'
+  - 'Connecting a client via `server.connect()` for automatic base URL wiring'
+  - 'Proper lifecycle management with `beforeAll` / `afterAll` for setup and teardown'
+  - 'Using the `toContainTool` custom matcher from `@frontmcp/testing`'
+---
+
+# Basic E2E Test with McpTestClient
+
+Set up a basic E2E test that starts a server, connects a client, and verifies tools are listed.
+
+## Code
+
+```typescript
+// src/__tests__/server.e2e.spec.ts
+import { McpTestClient, TestServer } from '@frontmcp/testing';
+import Server from '../src/main';
+
+describe('Server E2E', () => {
+  let client: McpTestClient;
+  let server: TestServer;
+
+  beforeAll(async () => {
+    server = await TestServer.create(Server);
+    client = await server.connect();
+  });
+
+  afterAll(async () => {
+    await client.close();
+    await server.dispose();
+  });
+
+  it('should list all tools', async () => {
+    const { tools } = await client.listTools();
+    expect(tools.length).toBeGreaterThan(0);
+    expect(tools).toContainTool('add_numbers');
+  });
+
+  it('should list resources', async () => {
+    const { resources } = await client.listResources();
+    expect(resources.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should list prompts', async () => {
+    const result = await client.getPrompt('summarize', { topic: 'testing' });
+    expect(result.messages).toBeDefined();
+    expect(result.messages.length).toBeGreaterThan(0);
+  });
+});
+```
+
+## What This Demonstrates
+
+- Using `TestServer.create()` to start a server from its module export
+- Connecting a client via `server.connect()` for automatic base URL wiring
+- Proper lifecycle management with `beforeAll` / `afterAll` for setup and teardown
+- Using the `toContainTool` custom matcher from `@frontmcp/testing`
+
+## Related
+
+- See `test-e2e-handler` for the full E2E handler testing reference

package/catalog/frontmcp-testing/examples/test-e2e-handler/manual-client-with-transport.md

@@ -0,0 +1,72 @@
+---
+name: manual-client-with-transport
+reference: test-e2e-handler
+level: advanced
+description: 'Use `McpTestClient.create()` with explicit transport settings for fine-grained control over E2E tests.'
+tags: [testing, session, transport, e2e, handler, manual]
+features:
+  - 'Using `TestServer.start()` with an explicit command and port for process-based server startup'
+  - "Building a client with `McpTestClient.create().withTransport('modern').buildAndConnect()` for streamable HTTP + strict sessions"
+  - 'Using `server.info.baseUrl` to wire the client to the correct address'
+  - 'Separate `disconnect()` / `stop()` calls for client and server teardown'
+  - 'The `toBeError()` and `toHaveTextContent()` custom matchers'
+---
+
+# Manual McpTestClient with Transport Configuration
+
+Use `McpTestClient.create()` with explicit transport settings for fine-grained control over E2E tests.
+
+## Code
+
+```typescript
+// src/__tests__/advanced.e2e.spec.ts
+import { McpTestClient, TestServer } from '@frontmcp/testing';
+
+describe('Advanced E2E with Transport Config', () => {
+  let server: TestServer;
+  let client: McpTestClient;
+
+  beforeAll(async () => {
+    server = await TestServer.start({
+      command: 'npx tsx src/main.ts',
+      port: 3004,
+    });
+
+    client = await McpTestClient.create({ baseUrl: server.info.baseUrl }).withTransport('modern').buildAndConnect();
+  });
+
+  afterAll(async () => {
+    await client.disconnect();
+    await server.stop();
+  });
+
+  it('should list tools after initialization', async () => {
+    const tools = await client.tools.list();
+    expect(tools.length).toBeGreaterThan(0);
+  });
+
+  it('should handle tool errors gracefully', async () => {
+    const result = await client.tools.call('nonexistent_tool', {});
+    expect(result).toBeError();
+  });
+
+  it('should call tool and verify result shape', async () => {
+    const result = await client.tools.call('add_numbers', { a: 1, b: 2 });
+    expect(result).toBeSuccessful();
+    expect(result).toHaveTextContent('3');
+  });
+});
+```
+
+## What This Demonstrates
+
+- Using `TestServer.start()` with an explicit command and port for process-based server startup
+- Building a client with `McpTestClient.create().withTransport('modern').buildAndConnect()` for streamable HTTP + strict sessions
+- Using `server.info.baseUrl` to wire the client to the correct address
+- Separate `disconnect()` / `stop()` calls for client and server teardown
+- The `toBeError()` and `toHaveTextContent()` custom matchers
+
+## Related
+
+- See `test-e2e-handler` for the full E2E handler testing reference
+- See `setup-testing` for fixture-based E2E patterns

package/catalog/frontmcp-testing/examples/test-e2e-handler/tool-call-and-error-e2e.md

@@ -0,0 +1,73 @@
+---
+name: tool-call-and-error-e2e
+reference: test-e2e-handler
+level: intermediate
+description: 'Test successful tool calls and verify that invalid inputs produce proper error responses over the full MCP protocol.'
+tags: [testing, e2e, handler, tool, call, error]
+features:
+  - 'Calling tools via `client.callTool()` and asserting success with `toBeSuccessful()`'
+  - 'Verifying text content in tool results with `result.content[0].text`'
+  - 'Checking `result.isError` for invalid input and nonexistent tool calls'
+  - 'Testing edge cases like zero values and missing optional parameters'
+---
+
+# E2E Testing Tool Calls and Error Responses
+
+Test successful tool calls and verify that invalid inputs produce proper error responses over the full MCP protocol.
+
+## Code
+
+```typescript
+// src/__tests__/tool-calls.e2e.spec.ts
+import { McpTestClient, TestServer } from '@frontmcp/testing';
+import Server from '../src/main';
+
+describe('Tool Call E2E', () => {
+  let client: McpTestClient;
+  let server: TestServer;
+
+  beforeAll(async () => {
+    server = await TestServer.create(Server);
+    client = await server.connect();
+  });
+
+  afterAll(async () => {
+    await client.close();
+    await server.dispose();
+  });
+
+  it('should call a tool and get a successful result', async () => {
+    const result = await client.callTool('add_numbers', { a: 5, b: 3 });
+    expect(result).toBeSuccessful();
+    expect(result.content[0].text).toContain('8');
+  });
+
+  it('should return isError for invalid input', async () => {
+    const result = await client.callTool('add_numbers', { a: 'bad' });
+    expect(result.isError).toBe(true);
+  });
+
+  it('should return error for nonexistent tool', async () => {
+    const result = await client.callTool('nonexistent_tool', {});
+    expect(result.isError).toBe(true);
+  });
+
+  it('should handle tool with optional parameters', async () => {
+    const result = await client.callTool('add_numbers', { a: 10, b: 0 });
+    expect(result).toBeSuccessful();
+    expect(result.content[0].text).toContain('10');
+  });
+});
+```
+
+## What This Demonstrates
+
+- Calling tools via `client.callTool()` and asserting success with `toBeSuccessful()`
+- Verifying text content in tool results with `result.content[0].text`
+- Checking `result.isError` for invalid input and nonexistent tool calls
+- Testing edge cases like zero values and missing optional parameters
+
+## Related
+
+- See `test-e2e-handler` for the full E2E handler testing reference
+- See `test-tool-unit` for unit-level tool testing

package/catalog/frontmcp-testing/examples/test-tool-unit/basic-tool-test.md

@@ -0,0 +1,69 @@
+---
+name: basic-tool-test
+reference: test-tool-unit
+level: basic
+description: "Test a simple tool's `execute()` method with mock context and verify the output."
+tags: [testing, tool, unit]
+features:
+  - 'Creating a mock `ToolContext` with all required methods (`get`, `tryGet`, `fail`, `mark`, `notify`, `respondProgress`)'
+  - 'Assigning the mock context to the tool instance via `Object.assign`'
+  - 'Testing multiple input scenarios including edge cases (negatives, zero)'
+---
+
+# Basic Tool Unit Test
+
+Test a simple tool's `execute()` method with mock context and verify the output.
+
+## Code
+
+```typescript
+// src/tools/__tests__/add.tool.spec.ts
+import { ToolContext } from '@frontmcp/sdk';
+import { AddTool } from '../add.tool';
+
+describe('AddTool', () => {
+  let tool: AddTool;
+
+  beforeEach(() => {
+    tool = new AddTool();
+
+    const ctx = {
+      get: jest.fn(),
+      tryGet: jest.fn(),
+      fail: jest.fn((err) => {
+        throw err;
+      }),
+      mark: jest.fn(),
+      notify: jest.fn(),
+      respondProgress: jest.fn(),
+    } as unknown as ToolContext;
+
+    Object.assign(tool, ctx);
+  });
+
+  it('should add two numbers', async () => {
+    const result = await tool.execute({ a: 2, b: 3 });
+    expect(result).toEqual({ sum: 5 });
+  });
+
+  it('should handle negative numbers', async () => {
+    const result = await tool.execute({ a: -1, b: -2 });
+    expect(result).toEqual({ sum: -3 });
+  });
+
+  it('should handle zero values', async () => {
+    const result = await tool.execute({ a: 0, b: 0 });
+    expect(result).toEqual({ sum: 0 });
+  });
+});
+```
+
+## What This Demonstrates
+
+- Creating a mock `ToolContext` with all required methods (`get`, `tryGet`, `fail`, `mark`, `notify`, `respondProgress`)
+- Assigning the mock context to the tool instance via `Object.assign`
+- Testing multiple input scenarios including edge cases (negatives, zero)
+
+## Related
+
+- See `test-tool-unit` for the full tool unit testing reference

package/catalog/frontmcp-testing/examples/test-tool-unit/schema-validation-test.md

@@ -0,0 +1,82 @@
+---
+name: schema-validation-test
+reference: test-tool-unit
+level: intermediate
+description: "Validate that a tool's Zod input schema rejects invalid data before `execute()` is called."
+tags: [testing, tool, unit, schema, validation]
+features:
+  - 'Testing the Zod input schema separately from the `execute()` method'
+  - 'Using `safeParse()` to check validation results without throwing'
+  - 'Covering rejection of wrong types, missing fields, and empty input'
+  - 'Combining schema validation with execution to test the full flow'
+---
+
+# Testing Zod Schema Validation for Tool Input
+
+Validate that a tool's Zod input schema rejects invalid data before `execute()` is called.
+
+## Code
+
+```typescript
+// src/tools/__tests__/add.tool.schema.spec.ts
+import { z } from 'zod';
+import { ToolContext } from '@frontmcp/sdk';
+import { AddTool } from '../add.tool';
+
+describe('AddTool schema validation', () => {
+  const schema = z.object({ a: z.number(), b: z.number() });
+
+  it('should accept valid numeric input', () => {
+    const result = schema.safeParse({ a: 5, b: 10 });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toEqual({ a: 5, b: 10 });
+    }
+  });
+
+  it('should reject string values for numeric fields', () => {
+    const result = schema.safeParse({ a: 'not-a-number', b: 3 });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject missing required fields', () => {
+    const result = schema.safeParse({ a: 5 });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject empty input', () => {
+    const result = schema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+
+  it('should coerce valid input and produce correct output', async () => {
+    const tool = new AddTool();
+    const ctx = {
+      get: jest.fn(),
+      tryGet: jest.fn(),
+      fail: jest.fn((err) => {
+        throw err;
+      }),
+      mark: jest.fn(),
+      notify: jest.fn(),
+      respondProgress: jest.fn(),
+    } as unknown as ToolContext;
+    Object.assign(tool, ctx);
+
+    const parsed = schema.parse({ a: 7, b: 3 });
+    const result = await tool.execute(parsed);
+    expect(result).toEqual({ sum: 10 });
+  });
+});
+```
+
+## What This Demonstrates
+
+- Testing the Zod input schema separately from the `execute()` method
+- Using `safeParse()` to check validation results without throwing
+- Covering rejection of wrong types, missing fields, and empty input
+- Combining schema validation with execution to test the full flow
+
+## Related
+
+- See `test-tool-unit` for the full tool unit testing reference

package/catalog/frontmcp-testing/examples/test-tool-unit/tool-error-handling-test.md

@@ -0,0 +1,92 @@
+---
+name: tool-error-handling-test
+reference: test-tool-unit
+level: advanced
+description: 'Test that a tool throws the correct MCP error classes with proper error codes and JSON-RPC error shapes.'
+tags: [testing, json-rpc, tool, unit, error, handling]
+features:
+  - 'Verifying specific error classes with `toBeInstanceOf` instead of just checking that something threw'
+  - 'Asserting MCP error codes from `MCP_ERROR_CODES` constants'
+  - 'Validating the JSON-RPC error shape returned by `toJsonRpcError()`'
+  - 'Testing both success and failure paths in the same suite'
+---
+
+# Testing Tool Error Handling and Error Classes
+
+Test that a tool throws the correct MCP error classes with proper error codes and JSON-RPC error shapes.
+
+## Code
+
+```typescript
+// src/tools/__tests__/lookup.tool.spec.ts
+import { ToolContext } from '@frontmcp/sdk';
+import { ResourceNotFoundError, MCP_ERROR_CODES } from '@frontmcp/sdk';
+import { LookupTool } from '../lookup.tool';
+
+describe('LookupTool error handling', () => {
+  let tool: LookupTool;
+
+  beforeEach(() => {
+    tool = new LookupTool();
+
+    const ctx = {
+      get: jest.fn(),
+      tryGet: jest.fn(),
+      fail: jest.fn((err) => {
+        throw err;
+      }),
+      mark: jest.fn(),
+      notify: jest.fn(),
+      respondProgress: jest.fn(),
+    } as unknown as ToolContext;
+
+    Object.assign(tool, ctx);
+  });
+
+  it('should throw ResourceNotFoundError for missing resource', async () => {
+    await expect(tool.execute({ id: 'nonexistent' })).rejects.toThrow(ResourceNotFoundError);
+  });
+
+  it('should produce correct MCP error code', async () => {
+    try {
+      await tool.execute({ id: 'nonexistent' });
+      fail('Expected an error to be thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(ResourceNotFoundError);
+      expect((err as ResourceNotFoundError).mcpErrorCode).toBe(MCP_ERROR_CODES.RESOURCE_NOT_FOUND);
+    }
+  });
+
+  it('should produce valid JSON-RPC error shape', async () => {
+    try {
+      await tool.execute({ id: 'nonexistent' });
+      fail('Expected an error to be thrown');
+    } catch (err) {
+      const rpc = (err as ResourceNotFoundError).toJsonRpcError();
+      expect(rpc).toEqual({
+        code: -32002,
+        message: expect.any(String),
+        data: expect.objectContaining({ uri: expect.any(String) }),
+      });
+    }
+  });
+
+  it('should succeed for valid resource id', async () => {
+    const result = await tool.execute({ id: 'existing-123' });
+    expect(result).toBeDefined();
+    expect(result.content).toBeDefined();
+  });
+});
+```
+
+## What This Demonstrates
+
+- Verifying specific error classes with `toBeInstanceOf` instead of just checking that something threw
+- Asserting MCP error codes from `MCP_ERROR_CODES` constants
+- Validating the JSON-RPC error shape returned by `toJsonRpcError()`
+- Testing both success and failure paths in the same suite
+
+## Related
+
+- See `test-tool-unit` for the full tool unit testing reference
+- See `setup-testing` for error class testing patterns

package/catalog/frontmcp-testing/references/setup-testing.md

@@ -551,6 +551,16 @@ node scripts/fix-unused-imports.mjs feature/my-branch
 | Istanbul shows 0% coverage for async methods | TypeScript compilation source-map mismatch              | Known issue with `ts-jest` and certain async patterns; check `tsconfig.spec.json` source-map settings |
 | Auth E2E test returns 401 unexpectedly       | Token not set or expired                                | Call `mcp.setAuthToken(token)` before the tool call; use `auth.createToken()` with valid claims       |
 
+## Examples
+
+| Example                                                                                         | Level        | Description                                                                                                                                       |
+| ----------------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`fixture-based-e2e-test`](../examples/setup-testing/fixture-based-e2e-test.md)                 | Advanced     | Write E2E tests using the fixture API from `@frontmcp/testing` that manages server lifecycle automatically and uses MCP-specific custom matchers. |
+| [`jest-config-with-coverage`](../examples/setup-testing/jest-config-with-coverage.md)           | Basic        | Set up a Jest configuration file that enforces 95%+ coverage across all metrics for a FrontMCP library.                                           |
+| [`unit-test-tool-resource-prompt`](../examples/setup-testing/unit-test-tool-resource-prompt.md) | Intermediate | Write unit tests for the three core MCP primitives, verifying that outputs match the expected MCP response shapes.                                |
+
+> See all examples in [`examples/setup-testing/`](../examples/setup-testing/)
+
 ## Reference
 
 - [Testing Documentation](https://docs.agentfront.dev/frontmcp/testing/overview)