From 3fbb9a18372f2b6a675dd6c039ba52be76f3eeb4 Mon Sep 17 00:00:00 2001 From: TheSiahxyz <164138827+TheSiahxyz@users.noreply.github.com> Date: Fri, 16 Jan 2026 08:30:14 +0900 Subject: updates --- .../memory-mcp-server/.claude/commands/test.md | 305 +++++++++++++++++++++ 1 file changed, 305 insertions(+) create mode 100644 mcp-servers/memory-mcp-server/.claude/commands/test.md (limited to 'mcp-servers/memory-mcp-server/.claude/commands/test.md') diff --git a/mcp-servers/memory-mcp-server/.claude/commands/test.md b/mcp-servers/memory-mcp-server/.claude/commands/test.md new file mode 100644 index 0000000..e78843c --- /dev/null +++ b/mcp-servers/memory-mcp-server/.claude/commands/test.md @@ -0,0 +1,305 @@ +--- +description: Generate comprehensive tests for Memory MCP Server +argument-hint: "[file, function, MCP tool, or test scenario]" +allowed-tools: Read, Write, MultiEdit, Bash, Task, TodoWrite +--- + +# Memory MCP Server Test Generation + +Generate comprehensive test cases for $ARGUMENTS with focus on MCP protocol compliance and memory operations: + +## Unit Tests + +### MCP Protocol Tests + +```typescript +// Test MCP message handling +describe('MCP Protocol', () => { + it('should handle JSON-RPC 2.0 requests', async () => { + // Test request with id + // Test notification without id + // Test batch requests + }); + + it('should return proper error codes', async () => { + // -32700: Parse error + // -32600: Invalid request + // -32601: Method not found + // -32602: Invalid params + // -32603: Internal error + }); + + it('should validate tool parameters with Zod', async () => { + // Test required fields + // Test type validation + // Test nested schemas + }); +}); +``` + +### Memory Operations Tests + +```typescript +// Test memory CRUD operations +describe('Memory Operations', () => { + it('should create memory with embeddings', async () => { + // Test successful creation + // Test OpenAI API failure handling + // Test vector dimension validation + }); + + it('should perform vector similarity search', async () => { + // Test similarity threshold + // Test result limit + // Test empty results + // Test index usage + }); + + it('should handle memory lifecycle', async () => { + // Test expiration + // Test archival + // Test soft delete + // Test importance decay + }); + + it('should consolidate memories', async () => { + // Test deduplication + // Test summarization + // Test relationship creation + }); +}); +``` + +### Database Tests + +```typescript +// Test database operations +describe('Database Operations', () => { + it('should handle transactions', async () => { + // Test commit on success + // Test rollback on error + // Test isolation levels + }); + + it('should use pgvector correctly', async () => { + // Test vector operations + // Test distance calculations + // Test index scans + }); + + it('should maintain referential integrity', async () => { + // Test foreign keys + // Test cascade deletes + // Test orphan prevention + }); +}); +``` + +## Integration Tests + +### MCP Server Integration + +```typescript +// Test full MCP server flow +describe('MCP Server Integration', () => { + let server: MCPServer; + let client: MCPClient; + + beforeEach(async () => { + server = await createMemoryMCPServer(); + client = await connectMCPClient(server); + }); + + it('should register tools on connection', async () => { + const tools = await client.listTools(); + expect(tools).toContain('create_memory'); + expect(tools).toContain('search_memories'); + }); + + it('should handle tool execution', async () => { + const result = await client.executeTool('create_memory', { + content: 'Test memory', + type: 'fact' + }); + expect(result.id).toBeDefined(); + expect(result.embedding).toHaveLength(1536); + }); + + it('should maintain session isolation', async () => { + // Test multi-tenant boundaries + // Test companion isolation + // Test user context + }); +}); +``` + +### Vector Search Integration + +```typescript +// Test vector search functionality +describe('Vector Search Integration', () => { + it('should find similar memories', async () => { + // Create test memories + // Generate embeddings + // Test similarity search + // Verify ranking + }); + + it('should use indexes efficiently', async () => { + // Test IVFFlat performance + // Test HNSW performance + // Monitor query plans + }); +}); +``` + +## Edge Cases & Error Conditions + +```typescript +describe('Edge Cases', () => { + it('should handle malformed requests', async () => { + // Invalid JSON + // Missing required fields + // Wrong types + }); + + it('should handle resource limits', async () => { + // Max memory count per user + // Request size limits + // Rate limiting + }); + + it('should handle concurrent operations', async () => { + // Parallel memory creation + // Concurrent searches + // Session conflicts + }); + + it('should handle external service failures', async () => { + // Database down + // OpenAI API timeout + // Network errors + }); +}); +``` + +## Performance Tests + +```typescript +describe('Performance', () => { + it('should handle bulk operations', async () => { + // Batch memory creation + // Large result sets + // Pagination + }); + + it('should meet latency requirements', async () => { + // Vector search < 200ms + // CRUD operations < 100ms + // Tool registration < 50ms + }); + + it('should scale with data volume', async () => { + // Test with 10K memories + // Test with 100K memories + // Test with 1M memories + }); +}); +``` + +## Mock Strategies + +```typescript +// Mocking external dependencies +const mocks = { + // Mock OpenAI API + openai: { + embeddings: { + create: jest.fn().mockResolvedValue({ + data: [{ embedding: new Array(1536).fill(0.1) }] + }) + } + }, + + // Mock database + db: { + query: jest.fn(), + transaction: jest.fn() + }, + + // Mock MCP client + mcpClient: { + request: jest.fn(), + notify: jest.fn() + } +}; +``` + +## Test Data Fixtures + +```typescript +// Reusable test data +export const fixtures = { + memories: [ + { + content: 'User prefers dark mode', + type: 'preference', + importance: 0.8 + }, + { + content: 'Meeting scheduled for 3pm', + type: 'event', + expires_at: '2024-12-31' + } + ], + + embeddings: { + sample: new Array(1536).fill(0.1), + similar: new Array(1536).fill(0.09), + different: new Array(1536).fill(0.5) + }, + + mcpRequests: { + valid: { + jsonrpc: '2.0', + method: 'create_memory', + params: { content: 'Test' }, + id: 1 + }, + invalid: { + jsonrpc: '1.0', // Wrong version + method: 'unknown_method' + } + } +}; +``` + +## Test Coverage Requirements + +- **Unit Tests**: 90% code coverage +- **Integration Tests**: All critical paths +- **E2E Tests**: Core user journeys +- **Performance Tests**: Load scenarios +- **Security Tests**: Auth and isolation + +## Test Execution Commands + +```bash +# Run all tests +npm test + +# Run with coverage +npm run test:coverage + +# Run specific test file +npm test -- memory.test.ts + +# Run integration tests +npm run test:integration + +# Run performance tests +npm run test:perf + +# Watch mode for development +npm run test:watch +``` -- cgit v1.2.3