391 lines
14 KiB
TypeScript
391 lines
14 KiB
TypeScript
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
|
import { MCPServer, type MCPServerDependencies } from '../../src/main/engine/MCPServer';
|
|
|
|
// Mock all engine singletons
|
|
vi.mock('../../src/main/engine/PostEngine', () => ({
|
|
getPostEngine: vi.fn(),
|
|
}));
|
|
vi.mock('../../src/main/engine/MediaEngine', () => ({
|
|
getMediaEngine: vi.fn(),
|
|
}));
|
|
vi.mock('../../src/main/engine/ScriptEngine', () => ({
|
|
getScriptEngine: vi.fn(),
|
|
}));
|
|
vi.mock('../../src/main/engine/TemplateEngine', () => ({
|
|
getTemplateEngine: vi.fn(),
|
|
}));
|
|
vi.mock('../../src/main/engine/MetaEngine', () => ({
|
|
getMetaEngine: vi.fn(),
|
|
}));
|
|
vi.mock('../../src/main/engine/PostMediaEngine', () => ({
|
|
getPostMediaEngine: vi.fn(),
|
|
}));
|
|
vi.mock('../../src/main/engine/TagEngine', () => ({
|
|
getTagEngine: vi.fn(),
|
|
}));
|
|
|
|
function createMockPostEngine() {
|
|
return {
|
|
getAllPosts: vi.fn().mockResolvedValue({ items: [], hasMore: false, total: 0 }),
|
|
getPost: vi.fn().mockResolvedValue(null),
|
|
searchPosts: vi.fn().mockResolvedValue([]),
|
|
createPost: vi.fn().mockResolvedValue({
|
|
id: 'post-1', title: 'Test', slug: 'test', content: '', status: 'draft',
|
|
tags: [], categories: [], createdAt: new Date(), updatedAt: new Date(),
|
|
}),
|
|
updatePost: vi.fn().mockResolvedValue(null),
|
|
publishPost: vi.fn().mockResolvedValue(null),
|
|
deletePost: vi.fn().mockResolvedValue(true),
|
|
getTagsWithCounts: vi.fn().mockResolvedValue([]),
|
|
getCategoriesWithCounts: vi.fn().mockResolvedValue([]),
|
|
getBlogStats: vi.fn().mockResolvedValue({
|
|
totalPosts: 0, draftCount: 0, publishedCount: 0, archivedCount: 0,
|
|
oldestPostDate: null, newestPostDate: null, postsPerYear: [], tagCount: 0, categoryCount: 0,
|
|
}),
|
|
getLinkedBy: vi.fn().mockResolvedValue([]),
|
|
getLinksTo: vi.fn().mockResolvedValue([]),
|
|
getPostsFiltered: vi.fn().mockResolvedValue([]),
|
|
};
|
|
}
|
|
|
|
function createMockMediaEngine() {
|
|
return {
|
|
getAllMedia: vi.fn().mockResolvedValue([]),
|
|
getMedia: vi.fn().mockResolvedValue(null),
|
|
updateMedia: vi.fn().mockResolvedValue(null),
|
|
};
|
|
}
|
|
|
|
function createMockScriptEngine() {
|
|
return {
|
|
createScript: vi.fn().mockResolvedValue({
|
|
id: 'script-1', title: 'Test', slug: 'test', kind: 'macro',
|
|
entrypoint: 'main.py', content: '', enabled: true, version: 1,
|
|
filePath: '/test', createdAt: new Date(), updatedAt: new Date(),
|
|
}),
|
|
};
|
|
}
|
|
|
|
function createMockTemplateEngine() {
|
|
return {
|
|
createTemplate: vi.fn().mockResolvedValue({
|
|
id: 'tpl-1', title: 'Test', slug: 'test', kind: 'post',
|
|
enabled: true, version: 1, filePath: '/test', content: '',
|
|
createdAt: new Date(), updatedAt: new Date(),
|
|
}),
|
|
};
|
|
}
|
|
|
|
function createMockMetaEngine() {
|
|
return {
|
|
getProjectMetadata: vi.fn().mockResolvedValue(null),
|
|
};
|
|
}
|
|
|
|
function createMockPostMediaEngine() {
|
|
return {
|
|
getLinkedMediaDataForPost: vi.fn().mockResolvedValue([]),
|
|
getLinkedPostsForMedia: vi.fn().mockResolvedValue([]),
|
|
};
|
|
}
|
|
|
|
function createMockTagEngine() {
|
|
return {
|
|
getTagsWithCounts: vi.fn().mockResolvedValue([]),
|
|
};
|
|
}
|
|
|
|
/** Create stable mock instances that are returned by getter functions */
|
|
function createDependencies() {
|
|
const mockPostEngine = createMockPostEngine();
|
|
const mockMediaEngine = createMockMediaEngine();
|
|
const mockScriptEngine = createMockScriptEngine();
|
|
const mockTemplateEngine = createMockTemplateEngine();
|
|
const mockMetaEngine = createMockMetaEngine();
|
|
const mockPostMediaEngine = createMockPostMediaEngine();
|
|
const mockTagEngine = createMockTagEngine();
|
|
|
|
const deps: MCPServerDependencies = {
|
|
getPostEngine: () => mockPostEngine,
|
|
getMediaEngine: () => mockMediaEngine,
|
|
getScriptEngine: () => mockScriptEngine,
|
|
getTemplateEngine: () => mockTemplateEngine,
|
|
getMetaEngine: () => mockMetaEngine,
|
|
getPostMediaEngine: () => mockPostMediaEngine,
|
|
getTagEngine: () => mockTagEngine,
|
|
};
|
|
|
|
return { deps, mockPostEngine, mockMediaEngine, mockScriptEngine, mockTemplateEngine, mockMetaEngine, mockPostMediaEngine, mockTagEngine };
|
|
}
|
|
|
|
/** Helper: check if a key exists in an McpServer internal registry (plain object) */
|
|
function hasRegistered(mcpServer: unknown, registry: string, name: string): boolean {
|
|
const obj = (mcpServer as Record<string, Record<string, unknown>>)[registry];
|
|
return obj != null && name in obj;
|
|
}
|
|
|
|
describe('MCPServer', () => {
|
|
let server: MCPServer;
|
|
let deps: MCPServerDependencies;
|
|
let mockPostEngine: ReturnType<typeof createMockPostEngine>;
|
|
let mockMediaEngine: ReturnType<typeof createMockMediaEngine>;
|
|
let mockScriptEngine: ReturnType<typeof createMockScriptEngine>;
|
|
let mockTemplateEngine: ReturnType<typeof createMockTemplateEngine>;
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
const mocks = createDependencies();
|
|
deps = mocks.deps;
|
|
mockPostEngine = mocks.mockPostEngine;
|
|
mockMediaEngine = mocks.mockMediaEngine;
|
|
mockScriptEngine = mocks.mockScriptEngine;
|
|
mockTemplateEngine = mocks.mockTemplateEngine;
|
|
server = new MCPServer(deps);
|
|
});
|
|
|
|
describe('constructor', () => {
|
|
it('creates an MCPServer instance', () => {
|
|
expect(server).toBeInstanceOf(MCPServer);
|
|
});
|
|
});
|
|
|
|
describe('createMcpServer', () => {
|
|
it('creates an McpServer with registered tools', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(mcpServer).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('proposal store', () => {
|
|
it('exposes the proposal store', () => {
|
|
expect(server.proposalStore).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('registered tools', () => {
|
|
it('registers search_posts tool', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredTools', 'search_posts')).toBe(true);
|
|
});
|
|
|
|
it('registers draft_post tool', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredTools', 'draft_post')).toBe(true);
|
|
});
|
|
|
|
it('registers propose_script tool', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredTools', 'propose_script')).toBe(true);
|
|
});
|
|
|
|
it('registers propose_template tool', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredTools', 'propose_template')).toBe(true);
|
|
});
|
|
|
|
it('registers propose_media_metadata tool', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredTools', 'propose_media_metadata')).toBe(true);
|
|
});
|
|
|
|
it('registers propose_post_metadata tool', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredTools', 'propose_post_metadata')).toBe(true);
|
|
});
|
|
|
|
it('registers accept_proposal tool', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredTools', 'accept_proposal')).toBe(true);
|
|
});
|
|
|
|
it('registers discard_proposal tool', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredTools', 'discard_proposal')).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('registered resources', () => {
|
|
it('registers bds://posts resource', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResources', 'bds://posts')).toBe(true);
|
|
});
|
|
|
|
it('registers bds://media resource', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResources', 'bds://media')).toBe(true);
|
|
});
|
|
|
|
it('registers bds://tags resource', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResources', 'bds://tags')).toBe(true);
|
|
});
|
|
|
|
it('registers bds://categories resource', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResources', 'bds://categories')).toBe(true);
|
|
});
|
|
|
|
it('registers bds://stats resource', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResources', 'bds://stats')).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('registered resource templates', () => {
|
|
it('registers post resource template', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResourceTemplates', 'post')).toBe(true);
|
|
});
|
|
|
|
it('registers media-item resource template', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResourceTemplates', 'media-item')).toBe(true);
|
|
});
|
|
|
|
it('registers post-backlinks resource template', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResourceTemplates', 'post-backlinks')).toBe(true);
|
|
});
|
|
|
|
it('registers post-outlinks resource template', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResourceTemplates', 'post-outlinks')).toBe(true);
|
|
});
|
|
|
|
it('registers post-media resource template', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResourceTemplates', 'post-media')).toBe(true);
|
|
});
|
|
|
|
it('registers media-posts resource template', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredResourceTemplates', 'media-posts')).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('registered prompts', () => {
|
|
it('registers draft-blog-post prompt', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredPrompts', 'draft-blog-post')).toBe(true);
|
|
});
|
|
|
|
it('registers improve-media-metadata prompt', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredPrompts', 'improve-media-metadata')).toBe(true);
|
|
});
|
|
|
|
it('registers content-audit prompt', () => {
|
|
const mcpServer = server.createMcpServer();
|
|
expect(hasRegistered(mcpServer, '_registeredPrompts', 'content-audit')).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('start and stop', () => {
|
|
it('starts the server and returns a port', async () => {
|
|
const port = await server.start(0);
|
|
expect(port).toBeGreaterThan(0);
|
|
await server.stop();
|
|
});
|
|
|
|
it('stop is idempotent', async () => {
|
|
await server.start(0);
|
|
await server.stop();
|
|
await expect(server.stop()).resolves.toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('cleanup', () => {
|
|
it('cleans up proposals and stops the server', async () => {
|
|
server.proposalStore.create('draftPost', { postId: 'test' });
|
|
await server.start(0);
|
|
await server.cleanup();
|
|
expect(server.proposalStore.getAll()).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe('accept_proposal', () => {
|
|
it('accepts a draftPost proposal by publishing', async () => {
|
|
mockPostEngine.publishPost.mockResolvedValue({
|
|
id: 'post-1', title: 'Test', slug: 'test', content: '', status: 'published',
|
|
tags: [], categories: [], createdAt: new Date(), updatedAt: new Date(), publishedAt: new Date(),
|
|
});
|
|
|
|
const proposalId = server.proposalStore.create('draftPost', { postId: 'post-1' });
|
|
const result = await server.acceptProposal(proposalId);
|
|
expect(result.success).toBe(true);
|
|
expect(mockPostEngine.publishPost).toHaveBeenCalledWith('post-1');
|
|
expect(server.proposalStore.get(proposalId)).toBeUndefined();
|
|
});
|
|
|
|
it('accepts a proposeScript proposal by creating script', async () => {
|
|
const proposalId = server.proposalStore.create('proposeScript', {
|
|
title: 'My Script', kind: 'macro', content: 'print("hello")',
|
|
});
|
|
const result = await server.acceptProposal(proposalId);
|
|
expect(result.success).toBe(true);
|
|
expect(mockScriptEngine.createScript).toHaveBeenCalledWith({
|
|
title: 'My Script', kind: 'macro', content: 'print("hello")',
|
|
});
|
|
expect(server.proposalStore.get(proposalId)).toBeUndefined();
|
|
});
|
|
|
|
it('accepts a proposeTemplate proposal by creating template', async () => {
|
|
const proposalId = server.proposalStore.create('proposeTemplate', {
|
|
title: 'My Template', kind: 'post', content: '<h1>{{ title }}</h1>',
|
|
});
|
|
const result = await server.acceptProposal(proposalId);
|
|
expect(result.success).toBe(true);
|
|
expect(mockTemplateEngine.createTemplate).toHaveBeenCalledWith({
|
|
title: 'My Template', kind: 'post', content: '<h1>{{ title }}</h1>',
|
|
});
|
|
});
|
|
|
|
it('accepts a proposeMediaMetadata proposal by updating media', async () => {
|
|
mockMediaEngine.updateMedia.mockResolvedValue({ id: 'media-1' });
|
|
const proposalId = server.proposalStore.create('proposeMediaMetadata', {
|
|
mediaId: 'media-1', changes: { alt: 'New alt text' },
|
|
});
|
|
const result = await server.acceptProposal(proposalId);
|
|
expect(result.success).toBe(true);
|
|
expect(mockMediaEngine.updateMedia).toHaveBeenCalledWith('media-1', { alt: 'New alt text' });
|
|
});
|
|
|
|
it('accepts a proposePostMetadata proposal by updating post', async () => {
|
|
mockPostEngine.updatePost.mockResolvedValue({ id: 'post-1' });
|
|
const proposalId = server.proposalStore.create('proposePostMetadata', {
|
|
postId: 'post-1', changes: { title: 'Updated Title' },
|
|
});
|
|
const result = await server.acceptProposal(proposalId);
|
|
expect(result.success).toBe(true);
|
|
expect(mockPostEngine.updatePost).toHaveBeenCalledWith('post-1', { title: 'Updated Title' });
|
|
});
|
|
|
|
it('returns failure for non-existent proposal', async () => {
|
|
const result = await server.acceptProposal('non-existent');
|
|
expect(result.success).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('discard_proposal', () => {
|
|
it('discards a draftPost proposal by deleting the post', async () => {
|
|
const proposalId = server.proposalStore.create('draftPost', { postId: 'post-1' });
|
|
const result = await server.discardProposal(proposalId);
|
|
expect(result.success).toBe(true);
|
|
expect(mockPostEngine.deletePost).toHaveBeenCalledWith('post-1');
|
|
expect(server.proposalStore.get(proposalId)).toBeUndefined();
|
|
});
|
|
|
|
it('discards a proposeScript proposal by removing from store', async () => {
|
|
const proposalId = server.proposalStore.create('proposeScript', { title: 'Script' });
|
|
const result = await server.discardProposal(proposalId);
|
|
expect(result.success).toBe(true);
|
|
expect(server.proposalStore.get(proposalId)).toBeUndefined();
|
|
});
|
|
|
|
it('returns failure for non-existent proposal', async () => {
|
|
const result = await server.discardProposal('non-existent');
|
|
expect(result.success).toBe(false);
|
|
});
|
|
});
|
|
});
|