/**
* Prompts Test Suite
*
* Tests for MCP prompt implementations
*/
import {
generateHumanDecisionPrompt,
generateExpertConsultationPrompt,
generateCreativeBrainstormPrompt,
generateSuggestFollowUpPrompt,
generateRefineDocumentPrompt,
ALL_PROMPTS,
PROMPT_GENERATORS
} from './index.js';
describe('MCP Prompts', () => {
describe('ALL_PROMPTS', () => {
it('should export all available prompts', () => {
expect(ALL_PROMPTS).toHaveLength(5);
expect(ALL_PROMPTS.map(p => p.name)).toEqual([
'human-decision',
'expert-consultation',
'creative-brainstorm',
'suggest-follow-up-questions',
'refine-document'
]);
});
it('should have valid prompt structures', () => {
ALL_PROMPTS.forEach(prompt => {
expect(prompt.name).toBeDefined();
expect(prompt.description).toBeDefined();
expect(prompt.arguments).toBeDefined();
expect(Array.isArray(prompt.arguments)).toBe(true);
});
});
});
describe('PROMPT_GENERATORS', () => {
it('should have generators for all prompts', () => {
const generatorNames = Object.keys(PROMPT_GENERATORS);
const promptNames = ALL_PROMPTS.map(p => p.name);
expect(generatorNames.sort()).toEqual(promptNames.sort());
});
});
describe('generateHumanDecisionPrompt', () => {
it('should generate basic prompt with required args', async () => {
const result = await generateHumanDecisionPrompt({
context: 'Should we implement feature X?'
});
expect(result.description).toContain('Should we implement feature X?');
expect(result.messages).toHaveLength(1);
expect(result.messages[0].role).toBe('user');
expect(result.messages[0].content.type).toBe('text');
expect(result.messages[0].content.text).toContain('Should we implement feature X?');
});
it('should include optional parameters when provided', async () => {
const result = await generateHumanDecisionPrompt({
context: 'Database migration decision',
options: '1. MySQL 2. PostgreSQL 3. Stay with current',
urgency: 'high',
domain: 'technical'
});
const text = result.messages[0].content.text;
expect(text).toContain('Database migration decision');
expect(text).toContain('1. MySQL 2. PostgreSQL 3. Stay with current');
expect(text).toContain('high');
expect(text).toContain('technical');
});
});
describe('generateExpertConsultationPrompt', () => {
it('should generate basic prompt with required args', async () => {
const result = await generateExpertConsultationPrompt({
topic: 'Cloud architecture',
expertise_area: 'DevOps Engineering'
});
expect(result.description).toContain('Cloud architecture');
expect(result.description).toContain('DevOps Engineering');
expect(result.messages).toHaveLength(1);
expect(result.messages[0].role).toBe('user');
const text = result.messages[0].content.text;
expect(text).toContain('Cloud architecture');
expect(text).toContain('DevOps Engineering');
});
it('should include all optional parameters', async () => {
const result = await generateExpertConsultationPrompt({
topic: 'API design',
expertise_area: 'Software Architecture',
specific_question: 'How to handle versioning?',
background_info: 'RESTful API with 1000+ endpoints',
expected_outcome: 'Versioning strategy document'
});
const text = result.messages[0].content.text;
expect(text).toContain('API design');
expect(text).toContain('How to handle versioning?');
expect(text).toContain('RESTful API with 1000+ endpoints');
expect(text).toContain('Versioning strategy document');
});
});
describe('generateCreativeBrainstormPrompt', () => {
it('should generate basic prompt with required args', async () => {
const result = await generateCreativeBrainstormPrompt({
challenge: 'Design a new mobile app interface'
});
expect(result.description).toContain('Design a new mobile app interface');
expect(result.messages).toHaveLength(1);
expect(result.messages[0].role).toBe('user');
const text = result.messages[0].content.text;
expect(text).toContain('Design a new mobile app interface');
expect(text).toContain('7 creative ideas'); // default idea count
});
it('should handle custom idea count and all optional parameters', async () => {
const result = await generateCreativeBrainstormPrompt({
challenge: 'Improve user onboarding',
goal: 'Reduce drop-off rate',
constraints: 'Mobile-first, under 5 minutes',
target_audience: 'Tech-savvy millennials',
inspiration_sources: 'Gaming apps, social media',
idea_count: 10
});
const text = result.messages[0].content.text;
expect(text).toContain('Improve user onboarding');
expect(text).toContain('Reduce drop-off rate');
expect(text).toContain('Mobile-first, under 5 minutes');
expect(text).toContain('Tech-savvy millennials');
expect(text).toContain('Gaming apps, social media');
expect(text).toContain('10 creative ideas');
});
});
describe('generateSuggestFollowUpPrompt', () => {
it('should generate basic prompt with required args', async () => {
const result = await generateSuggestFollowUpPrompt({
originalQuestion: 'What features should we prioritize?',
response: 'User authentication and dashboard improvements are most important'
});
expect(result.description).toContain('What features should we prioritize?');
expect(result.messages).toHaveLength(1);
expect(result.messages[0].role).toBe('user');
expect(result.messages[0].content.type).toBe('text');
const text = result.messages[0].content.text;
expect(text).toContain('What features should we prioritize?');
expect(text).toContain('User authentication and dashboard improvements are most important');
expect(text).toContain('**Response Type:** open'); // default
});
it('should include optional parameters when provided', async () => {
const result = await generateSuggestFollowUpPrompt({
originalQuestion: 'Which deployment strategy should we use?',
response: 'Blue-green deployment seems safer but takes longer',
goal: 'Create a deployment plan',
responseType: 'multiple-choice'
});
const text = result.messages[0].content.text;
expect(text).toContain('Which deployment strategy should we use?');
expect(text).toContain('Blue-green deployment seems safer but takes longer');
expect(text).toContain('Create a deployment plan');
expect(text).toContain('**Response Type:** multiple-choice');
});
it('should handle different response types', async () => {
const responseTypes = ['open', 'multiple-choice', 'hypothesis'] as const;
for (const responseType of responseTypes) {
const result = await generateSuggestFollowUpPrompt({
originalQuestion: 'Test question',
response: 'Test response',
responseType
});
const text = result.messages[0].content.text;
expect(text).toContain(`**Response Type:** ${responseType}`);
}
});
it('should include structured format instructions', async () => {
const result = await generateSuggestFollowUpPrompt({
originalQuestion: 'What should we build next?',
response: 'Mobile app would be good'
});
const text = result.messages[0].content.text;
expect(text).toContain('## Suggested Follow-up Questions');
expect(text).toContain('Priority:');
expect(text).toContain('Reasoning:');
expect(text).toContain('## Analysis Summary');
expect(text).toContain('Clarify ambiguities');
expect(text).toContain('Drill deeper');
expect(text).toContain('Explore implications');
});
it('should truncate long questions in description', async () => {
const longQuestion = 'This is a very long question that should be truncated because it exceeds the character limit for descriptions and we want to keep them concise';
const result = await generateSuggestFollowUpPrompt({
originalQuestion: longQuestion,
response: 'Short response'
});
expect(result.description).toContain('...');
expect(result.description.length).toBeLessThan(longQuestion.length + 50);
});
});
describe('generateRefineDocumentPrompt', () => {
it('should generate basic prompt with required args', async () => {
const result = await generateRefineDocumentPrompt({
documentName: 'Project Requirements.md'
});
expect(result.messages).toHaveLength(1);
expect(result.messages[0].role).toBe('user');
expect(result.messages[0].content.type).toBe('text');
const text = result.messages[0].content.text;
expect(text).toContain('**Doc‑Refine‑GPT**');
expect(text).toContain('iteratively improve a source document');
expect(text).toContain('ask-multiple-choice');
expect(text).toContain('ask-one-question');
expect(text).toContain('challenge-hypothesis');
expect(text).toContain('LOAD → ANALYSE → (IF needed) QUESTION → INCORPORATE ANSWER → REPEAT → DELIVER REFINED DOC');
});
it('should include document name in description', async () => {
const result = await generateRefineDocumentPrompt({
documentName: 'API Documentation'
});
expect(result.description).toContain('API Documentation');
const text = result.messages[0].content.text;
expect(text).toContain('iteratively improve a source document');
expect(text).toContain('# == END OF PROMPT ==');
});
});
describe('Prompt message format', () => {
it('should return valid PromptMessage format for all generators', async () => {
const testCases = [
() => generateHumanDecisionPrompt({ context: 'Test decision' }),
() => generateExpertConsultationPrompt({ topic: 'Test', expertise_area: 'Testing' }),
() => generateCreativeBrainstormPrompt({ challenge: 'Test challenge' }),
() => generateSuggestFollowUpPrompt({ originalQuestion: 'Test question', response: 'Test response' }),
() => generateRefineDocumentPrompt({ documentName: 'Test Document' })
];
for (const testCase of testCases) {
const result = await testCase();
expect(result.description).toBeDefined();
expect(typeof result.description).toBe('string');
expect(result.messages).toBeDefined();
expect(Array.isArray(result.messages)).toBe(true);
expect(result.messages.length).toBeGreaterThan(0);
result.messages.forEach(message => {
expect(message.role).toMatch(/^(user|assistant)$/);
expect(message.content).toBeDefined();
expect(message.content.type).toBe('text');
expect(typeof (message.content as any).text).toBe('string');
expect((message.content as any).text.length).toBeGreaterThan(0);
});
}
});
});
});
