documcp

/** * Basic unit tests for Knowledge Graph System * Tests basic instantiation and core functionality * Part of Issue #54 - Core Memory System Unit Tests */ import { promises as fs } from 'fs'; import path from 'path'; import os from 'os'; import { MemoryManager } from '../../src/memory/manager.js'; import { KnowledgeGraph, GraphNode, GraphEdge } from '../../src/memory/knowledge-graph.js'; describe('KnowledgeGraph', () => { let tempDir: string; let memoryManager: MemoryManager; let graph: KnowledgeGraph; beforeEach(async () => { // Create unique temp directory for each test tempDir = path.join( os.tmpdir(), `memory-graph-test-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`, ); await fs.mkdir(tempDir, { recursive: true }); // Create memory manager for knowledge graph memoryManager = new MemoryManager(tempDir); await memoryManager.initialize(); graph = new KnowledgeGraph(memoryManager); await graph.initialize(); }); afterEach(async () => { // Cleanup temp directory try { await fs.rm(tempDir, { recursive: true, force: true }); } catch (error) { // Ignore cleanup errors } }); describe('Basic Graph Operations', () => { test('should create knowledge graph instance', () => { expect(graph).toBeDefined(); expect(graph).toBeInstanceOf(KnowledgeGraph); }); test('should add nodes to the graph', () => { const projectNode: Omit<GraphNode, 'lastUpdated'> = { id: 'project:test-project', type: 'project', label: 'Test Project', properties: { language: 'typescript', framework: 'react', }, weight: 1.0, }; const addedNode = graph.addNode(projectNode); expect(addedNode).toBeDefined(); expect(addedNode.id).toBe('project:test-project'); expect(addedNode.type).toBe('project'); expect(addedNode.lastUpdated).toBeDefined(); }); test('should add edges to the graph', () => { // First add nodes const projectNode = graph.addNode({ id: 'project:web-app', type: 'project', label: 'Web App', properties: { language: 'typescript' }, weight: 1.0, }); const techNode = graph.addNode({ id: 'tech:react', type: 'technology', label: 'React', properties: { category: 'framework' }, weight: 1.0, }); // Add edge const edge: Omit<GraphEdge, 'id' | 'lastUpdated'> = { source: projectNode.id, target: techNode.id, type: 'uses', weight: 1.0, confidence: 0.9, properties: { importance: 'high' }, }; const addedEdge = graph.addEdge(edge); expect(addedEdge).toBeDefined(); expect(addedEdge.source).toBe(projectNode.id); expect(addedEdge.target).toBe(techNode.id); expect(addedEdge.id).toBeDefined(); }); test('should get all nodes', async () => { // Add some nodes graph.addNode({ id: 'project:test1', type: 'project', label: 'Test 1', properties: {}, weight: 1.0, }); graph.addNode({ id: 'tech:vue', type: 'technology', label: 'Vue', properties: {}, weight: 1.0, }); const nodes = await graph.getAllNodes(); expect(Array.isArray(nodes)).toBe(true); expect(nodes.length).toBe(2); }); test('should get all edges', async () => { // Add nodes and edges const node1 = graph.addNode({ id: 'project:test2', type: 'project', label: 'Test 2', properties: {}, weight: 1.0, }); const node2 = graph.addNode({ id: 'tech:angular', type: 'technology', label: 'Angular', properties: {}, weight: 1.0, }); graph.addEdge({ source: node1.id, target: node2.id, type: 'uses', weight: 1.0, confidence: 0.8, properties: {}, }); const edges = await graph.getAllEdges(); expect(Array.isArray(edges)).toBe(true); expect(edges.length).toBe(1); }); }); describe('Graph Queries', () => { test('should query nodes by type', () => { // Add multiple nodes of different types graph.addNode({ id: 'project:project-a', type: 'project', label: 'Project A', properties: {}, weight: 1.0, }); graph.addNode({ id: 'project:project-b', type: 'project', label: 'Project B', properties: {}, weight: 1.0, }); graph.addNode({ id: 'tech:vue', type: 'technology', label: 'Vue', properties: { category: 'framework' }, weight: 1.0, }); const results = graph.query({ nodeTypes: ['project'], }); expect(results).toBeDefined(); expect(Array.isArray(results.nodes)).toBe(true); expect(results.nodes.length).toBe(2); expect(results.nodes.every((node) => node.type === 'project')).toBe(true); }); test('should find connections for a node', async () => { // Add nodes and create connections const projectNode = graph.addNode({ id: 'project:connected-test', type: 'project', label: 'Connected Test', properties: {}, weight: 1.0, }); const techNode = graph.addNode({ id: 'tech:express', type: 'technology', label: 'Express', properties: {}, weight: 1.0, }); graph.addEdge({ source: projectNode.id, target: techNode.id, type: 'uses', weight: 1.0, confidence: 0.9, properties: {}, }); const connections = await graph.getConnections(projectNode.id); expect(Array.isArray(connections)).toBe(true); expect(connections.length).toBe(1); expect(connections[0]).toBe(techNode.id); }); test('should find paths between nodes', () => { // Add nodes and create a path const projectNode = graph.addNode({ id: 'project:path-test', type: 'project', label: 'Path Test Project', properties: {}, weight: 1.0, }); const techNode = graph.addNode({ id: 'tech:nodejs', type: 'technology', label: 'Node.js', properties: {}, weight: 1.0, }); graph.addEdge({ source: projectNode.id, target: techNode.id, type: 'uses', weight: 1.0, confidence: 0.9, properties: {}, }); const path = graph.findPath(projectNode.id, techNode.id); expect(path).toBeDefined(); expect(path?.nodes.length).toBe(2); expect(path?.edges.length).toBe(1); }); }); describe('Graph Analysis', () => { test('should build from memory entries', async () => { // Add some test memory entries first await memoryManager.remember( 'analysis', { language: { primary: 'python' }, framework: { name: 'django' }, }, { projectId: 'analysis-project', }, ); await memoryManager.remember( 'recommendation', { recommended: 'mkdocs', confidence: 0.9, }, { projectId: 'analysis-project', }, ); // Build graph from memories await graph.buildFromMemories(); const nodes = await graph.getAllNodes(); // The buildFromMemories method might be implemented differently // Just verify it doesn't throw and returns an array expect(Array.isArray(nodes)).toBe(true); // The graph might start empty, which is okay for this basic test if (nodes.length > 0) { // Optionally check node types if any were created const nodeTypes = [...new Set(nodes.map((n) => n.type))]; expect(nodeTypes.length).toBeGreaterThan(0); } }); test('should generate graph-based recommendations', async () => { // Add some memory data first await memoryManager.remember( 'analysis', { language: { primary: 'javascript' }, framework: { name: 'react' }, }, { projectId: 'rec-test-project', }, ); await graph.buildFromMemories(); const projectFeatures = { language: 'javascript', framework: 'react', }; const recommendations = await graph.getGraphBasedRecommendation(projectFeatures, [ 'docusaurus', 'gatsby', ]); expect(Array.isArray(recommendations)).toBe(true); // Even if no recommendations found, should return empty array }); test('should provide graph statistics', async () => { // Add some nodes graph.addNode({ id: 'project:stats-test', type: 'project', label: 'Stats Test', properties: {}, weight: 1.0, }); graph.addNode({ id: 'tech:webpack', type: 'technology', label: 'Webpack', properties: {}, weight: 1.0, }); const stats = await graph.getStatistics(); expect(stats).toBeDefined(); expect(typeof stats.nodeCount).toBe('number'); expect(typeof stats.edgeCount).toBe('number'); expect(typeof stats.nodesByType).toBe('object'); expect(typeof stats.averageConnectivity).toBe('number'); expect(Array.isArray(stats.mostConnectedNodes)).toBe(true); }); }); describe('Error Handling', () => { test('should handle removing non-existent nodes', async () => { const removed = await graph.removeNode('non-existent-node'); expect(removed).toBe(false); }); test('should handle concurrent graph operations', () => { // Create multiple nodes concurrently const nodes = Array.from({ length: 10 }, (_, i) => graph.addNode({ id: `project:concurrent-${i}`, type: 'project', label: `Concurrent Project ${i}`, properties: { index: i }, weight: 1.0, }), ); expect(nodes).toHaveLength(10); expect(nodes.every((node) => typeof node.id === 'string')).toBe(true); }); test('should handle invalid query parameters', () => { const results = graph.query({ nodeTypes: ['non-existent-type'], }); expect(results).toBeDefined(); expect(Array.isArray(results.nodes)).toBe(true); expect(results.nodes.length).toBe(0); }); test('should handle empty graph operations', async () => { // Test operations on empty graph const path = graph.findPath('non-existent-1', 'non-existent-2'); expect(path).toBeNull(); const connections = await graph.getConnections('non-existent-node'); expect(Array.isArray(connections)).toBe(true); expect(connections.length).toBe(0); }); }); describe('Persistence and Memory Integration', () => { test('should save and load from memory', async () => { // Add some data to the graph graph.addNode({ id: 'project:persistence-test', type: 'project', label: 'Persistence Test', properties: {}, weight: 1.0, }); // Save to memory await graph.saveToMemory(); // Create new graph and load const newGraph = new KnowledgeGraph(memoryManager); await newGraph.loadFromMemory(); const nodes = await newGraph.getAllNodes(); expect(nodes.length).toBeGreaterThanOrEqual(0); }); test('should handle empty graph statistics', async () => { const stats = await graph.getStatistics(); expect(stats).toBeDefined(); expect(typeof stats.nodeCount).toBe('number'); expect(typeof stats.edgeCount).toBe('number'); expect(stats.nodeCount).toBe(0); // Empty graph initially expect(stats.edgeCount).toBe(0); }); }); });