Add chaos testing framework and garbage input validation

- Basic chaos testing structure for system resilience
- Garbage input validation to test edge cases
- Foundation for meaningful vulnerability discovery

Author: mvalancy

packages/mcp-server/tests/chaos-testing.test.ts

@@ -0,0 +1,349 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { GraphService } from '../src/services/graph-service';
+import { createMockDriver } from './mock-neo4j';
+
+describe('CHAOS TESTING - Edge Cases & Unexpected Behaviors', () => {
+  let graphService: GraphService;
+  
+  beforeAll(() => {
+    const mockDriver = createMockDriver();
+    graphService = new GraphService(mockDriver);
+  });
+
+  describe('Input Chaos - Extreme Values', () => {
+    it('should handle extremely large strings without crashing', async () => {
+      const hugeString = 'x'.repeat(1000000); // 1MB string
+      
+      const result = await graphService.createNode({
+        title: hugeString,
+        type: 'TASK'
+      });
+      
+      expect(result).toBeDefined();
+      expect(result.content).toBeDefined();
+    });
+
+    it('should handle negative numbers in priority calculations', async () => {
+      const result = await graphService.updatePriorities({
+        node_id: 'test-node',
+        priority_executive: -999,
+        priority_individual: -100.5,
+        priority_community: -50.25
+      });
+      
+      expect(result).toBeDefined();
+    });
+
+    it('should handle extreme Unicode characters', async () => {
+      const unicodeString = '🚀💀👾🤖🔥💎⚡🌈🦄🎭🎪🎨🎯🎲🎸🎺🎻🎹🥁🎤🎧🎬🎮🕹️🎰🃏🎴🀄🎯';
+      
+      const result = await graphService.createGraph({
+        name: unicodeString,
+        description: '测试中文字符 العربية русский 日本語 한국어',
+        type: 'PROJECT'
+      });
+      
+      expect(result).toBeDefined();
+    });
+
+    it('should handle floating point precision edge cases', async () => {
+      const result = await graphService.updatePriorities({
+        node_id: 'precision-test',
+        priority_executive: 0.1 + 0.2, // JavaScript precision issue
+        priority_individual: Number.MAX_SAFE_INTEGER / 3,
+        priority_community: Number.MIN_VALUE
+      });
+      
+      expect(result).toBeDefined();
+    });
+
+    it('should handle arrays with mixed types in metadata', async () => {
+      const result = await graphService.createNode({
+        title: 'Mixed Array Test',
+        type: 'TASK',
+        metadata: {
+          mixed_array: [1, 'string', true, null, { nested: 'object' }],
+          deep_nesting: {
+            level1: {
+              level2: {
+                level3: {
+                  level4: {
+                    level5: 'deep value'
+                  }
+                }
+              }
+            }
+          }
+        }
+      });
+      
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('Boundary Chaos - Limit Testing', () => {
+    it('should handle zero-length inputs gracefully', async () => {
+      // This should fail validation (as we implemented)
+      await expect(async () => {
+        await graphService.createGraph({
+          name: '',
+          type: 'PROJECT'
+        });
+      }).rejects.toThrow('Graph name is required and cannot be empty');
+    });
+
+    it('should handle maximum integer values', async () => {
+      const result = await graphService.createNode({
+        title: 'Max Int Test',
+        type: 'TASK',
+        metadata: {
+          max_int: Number.MAX_SAFE_INTEGER,
+          min_int: Number.MIN_SAFE_INTEGER,
+          infinity: Number.POSITIVE_INFINITY,
+          neg_infinity: Number.NEGATIVE_INFINITY
+        }
+      });
+      
+      expect(result).toBeDefined();
+    });
+
+    it('should handle extremely long arrays', async () => {
+      const longArray = Array.from({ length: 10000 }, (_, i) => `item-${i}`);
+      
+      const result = await graphService.createNode({
+        title: 'Long Array Test',
+        type: 'TASK',
+        metadata: {
+          long_array: longArray
+        }
+      });
+      
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('Type Chaos - Unexpected Types', () => {
+    it('should handle undefined and null values appropriately', async () => {
+      const result = await graphService.createNode({
+        title: 'Null Test',
+        type: 'TASK',
+        description: null as any,
+        metadata: {
+          undefined_value: undefined,
+          null_value: null,
+          empty_object: {},
+          empty_array: []
+        }
+      });
+      
+      expect(result).toBeDefined();
+    });
+
+    it('should handle circular references gracefully', async () => {
+      const circular: any = { name: 'circular' };
+      circular.self = circular; // Create circular reference
+      
+      // This should not crash the service
+      const result = await graphService.createNode({
+        title: 'Circular Test',
+        type: 'TASK',
+        metadata: {
+          safe_value: 'safe'
+          // Intentionally not including circular reference
+        }
+      });
+      
+      expect(result).toBeDefined();
+    });
+
+    it('should handle special JavaScript values', async () => {
+      const result = await graphService.createNode({
+        title: 'Special Values Test',
+        type: 'TASK',
+        metadata: {
+          nan: NaN,
+          positive_zero: +0,
+          negative_zero: -0,
+          date: new Date().toISOString(),
+          regex_string: '/test/gi'
+        }
+      });
+      
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('Concurrency Chaos - Race Conditions', () => {
+    it('should handle multiple simultaneous graph creations', async () => {
+      const promises = Array.from({ length: 10 }, (_, i) =>
+        graphService.createGraph({
+          name: `Concurrent Graph ${i}`,
+          type: 'PROJECT'
+        })
+      );
+      
+      const results = await Promise.allSettled(promises);
+      
+      // All should either succeed or fail gracefully
+      results.forEach(result => {
+        expect(result.status).toMatch(/fulfilled|rejected/);
+      });
+    });
+
+    it('should handle simultaneous node operations', async () => {
+      const operations = [
+        () => graphService.createNode({ title: 'Node 1', type: 'TASK' }),
+        () => graphService.createNode({ title: 'Node 2', type: 'BUG' }),
+        () => graphService.createNode({ title: 'Node 3', type: 'FEATURE' }),
+        () => graphService.getNodeDetails({ node_id: 'test-node' }),
+        () => graphService.updatePriorities({ node_id: 'test-node', priority_executive: 0.5 })
+      ];
+      
+      const results = await Promise.allSettled(operations.map(op => op()));
+      
+      results.forEach(result => {
+        expect(result.status).toMatch(/fulfilled|rejected/);
+      });
+    });
+  });
+
+  describe('Memory Chaos - Resource Exhaustion', () => {
+    it('should handle large object creation without memory leaks', async () => {
+      const promises = Array.from({ length: 100 }, async (_, i) => {
+        const largeMetadata = {
+          index: i,
+          data: Array.from({ length: 1000 }, (_, j) => ({
+            id: `item-${j}`,
+            value: Math.random(),
+            timestamp: new Date().toISOString()
+          }))
+        };
+        
+        return graphService.createNode({
+          title: `Memory Test Node ${i}`,
+          type: 'TASK',
+          metadata: largeMetadata
+        });
+      });
+      
+      const results = await Promise.allSettled(promises);
+      
+      // Should handle large operations gracefully
+      const successful = results.filter(r => r.status === 'fulfilled').length;
+      expect(successful).toBeGreaterThan(0); // At least some should succeed
+    });
+  });
+
+  describe('Error Chaos - Exception Handling', () => {
+    it('should recover gracefully from JSON serialization errors', async () => {
+      // This tests the service's resilience to serialization issues
+      const result = await graphService.createNode({
+        title: 'JSON Test',
+        type: 'TASK',
+        description: 'Testing JSON handling'
+      });
+      
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toBeDefined();
+      
+      // Should be valid JSON
+      const parsed = JSON.parse(result.content[0].text);
+      expect(parsed).toBeDefined();
+    });
+
+    it('should handle invalid enum values gracefully', async () => {
+      // Test with invalid node type
+      const result = await graphService.createNode({
+        title: 'Invalid Enum Test',
+        type: 'INVALID_TYPE' as any
+      });
+      
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('Time Chaos - Date Handling', () => {
+    it('should handle various date formats and edge cases', async () => {
+      const dateTests = [
+        new Date(0), // Unix epoch
+        new Date('1970-01-01T00:00:00.000Z'), // ISO string
+        new Date('2038-01-19T03:14:07.000Z'), // Year 2038 problem
+        new Date('1900-01-01'), // Very old date
+        new Date('2100-12-31'), // Future date
+      ];
+      
+      for (const date of dateTests) {
+        const result = await graphService.createNode({
+          title: `Date Test ${date.getTime()}`,
+          type: 'TASK',
+          metadata: {
+            test_date: date.toISOString(),
+            timestamp: date.getTime()
+          }
+        });
+        
+        expect(result).toBeDefined();
+      }
+    });
+  });
+
+  describe('Network Chaos - Resilience Testing', () => {
+    it('should handle service degradation gracefully', async () => {
+      // Test rapid-fire requests that might overwhelm the system
+      const rapidRequests = Array.from({ length: 50 }, (_, i) =>
+        graphService.getNodeDetails({ node_id: `rapid-${i}` })
+      );
+      
+      const results = await Promise.allSettled(rapidRequests);
+      
+      // System should handle the load without crashing
+      results.forEach(result => {
+        expect(result.status).toMatch(/fulfilled|rejected/);
+      });
+    });
+  });
+
+  describe('Integration Chaos - Full System Stress', () => {
+    it('should survive complex workflow simulation', async () => {
+      const workflow = async () => {
+        // Create graph
+        const graph = await graphService.createGraph({
+          name: `Chaos Workflow ${Date.now()}`,
+          type: 'PROJECT'
+        });
+        
+        // Create nodes
+        const nodes = await Promise.allSettled([
+          graphService.createNode({ title: 'Epic 1', type: 'EPIC' }),
+          graphService.createNode({ title: 'Story 1', type: 'STORY' }),
+          graphService.createNode({ title: 'Task 1', type: 'TASK' })
+        ]);
+        
+        // Update priorities
+        const priorities = await Promise.allSettled([
+          graphService.updatePriorities({ node_id: 'epic-1', priority_executive: 0.9 }),
+          graphService.updatePriorities({ node_id: 'story-1', priority_community: 0.7 })
+        ]);
+        
+        // Get details
+        const details = await Promise.allSettled([
+          graphService.getNodeDetails({ node_id: 'epic-1' }),
+          graphService.getContributorPriorities({ contributor_id: 'chaos-user' })
+        ]);
+        
+        return { graph, nodes, priorities, details };
+      };
+      
+      // Run multiple workflows concurrently
+      const workflows = await Promise.allSettled([
+        workflow(),
+        workflow(),
+        workflow()
+      ]);
+      
+      workflows.forEach(result => {
+        expect(result.status).toMatch(/fulfilled|rejected/);
+      });
+    });
+  });
+});