holosphere 1.1.20 → 2.0.0-alpha1

package/tests/unit/ai/federation-ai.test.js

@@ -0,0 +1,344 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FederationAdvisor } from '../../../src/ai/federation-ai.js';
+
+describe('Unit: FederationAdvisor', () => {
+  let advisor;
+  let mockLLM;
+  let mockHolosphere;
+  let mockEmbeddings;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockLLM = {
+      getJSON: vi.fn()
+    };
+
+    mockHolosphere = {
+      getAll: vi.fn().mockResolvedValue([]),
+      getFederation: vi.fn().mockResolvedValue(null)
+    };
+
+    mockEmbeddings = {
+      embed: vi.fn(),
+      cosineSimilarity: vi.fn()
+    };
+
+    advisor = new FederationAdvisor(mockLLM, mockHolosphere, mockEmbeddings);
+  });
+
+  describe('Constructor', () => {
+    it('should initialize with LLM service', () => {
+      const a = new FederationAdvisor(mockLLM);
+      expect(a.llm).toBe(mockLLM);
+      expect(a.holosphere).toBeNull();
+      expect(a.embeddings).toBeNull();
+    });
+
+    it('should accept optional HoloSphere and Embeddings', () => {
+      expect(advisor.holosphere).toBe(mockHolosphere);
+      expect(advisor.embeddings).toBe(mockEmbeddings);
+    });
+  });
+
+  describe('setHoloSphere', () => {
+    it('should set HoloSphere instance', () => {
+      const a = new FederationAdvisor(mockLLM);
+      a.setHoloSphere(mockHolosphere);
+      expect(a.holosphere).toBe(mockHolosphere);
+    });
+  });
+
+  describe('setEmbeddings', () => {
+    it('should set Embeddings instance', () => {
+      const a = new FederationAdvisor(mockLLM);
+      a.setEmbeddings(mockEmbeddings);
+      expect(a.embeddings).toBe(mockEmbeddings);
+    });
+  });
+
+  describe('suggestFederations', () => {
+    it('should suggest federations based on content similarity', async () => {
+      mockHolosphere.getAll
+        .mockResolvedValueOnce([{ id: 1, title: 'Source Project' }])
+        .mockResolvedValueOnce([{ id: 2, title: 'Candidate Project' }]);
+
+      mockLLM.getJSON.mockResolvedValue([
+        {
+          holon: 'candidate1',
+          score: 0.85,
+          reasoning: 'Similar topics',
+          benefits: ['Knowledge sharing'],
+          type: 'similarity'
+        }
+      ]);
+
+      const result = await advisor.suggestFederations('source_holon', {
+        candidateHolons: ['candidate1'],
+        lens: 'projects'
+      });
+
+      expect(result.holon).toBe('source_holon');
+      expect(result.suggestions).toHaveLength(1);
+      expect(result.suggestions[0].score).toBe(0.85);
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const a = new FederationAdvisor(mockLLM);
+
+      await expect(a.suggestFederations('holon'))
+        .rejects.toThrow('HoloSphere instance required');
+    });
+
+    it('should return empty suggestions if source has no data', async () => {
+      mockHolosphere.getAll.mockResolvedValue([]);
+
+      const result = await advisor.suggestFederations('holon', {
+        candidateHolons: ['c1']
+      });
+
+      expect(result.suggestions).toEqual([]);
+      expect(result.message).toBe('No data in source holon');
+    });
+
+    it('should return empty suggestions if no candidates have data', async () => {
+      mockHolosphere.getAll
+        .mockResolvedValueOnce([{ id: 1 }])  // source has data
+        .mockResolvedValue([]);              // candidates empty
+
+      const result = await advisor.suggestFederations('holon', {
+        candidateHolons: ['c1', 'c2']
+      });
+
+      expect(result.suggestions).toEqual([]);
+      expect(result.message).toBe('No candidate holons with data');
+    });
+
+    it('should skip source holon in candidates', async () => {
+      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
+      mockLLM.getJSON.mockResolvedValue([]);
+
+      await advisor.suggestFederations('holon1', {
+        candidateHolons: ['holon1', 'holon2']
+      });
+
+      expect(mockHolosphere.getAll).toHaveBeenCalledTimes(2);
+    });
+
+    it('should respect maxSuggestions option', async () => {
+      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
+      mockLLM.getJSON.mockResolvedValue([
+        { holon: 'c1', score: 0.9 },
+        { holon: 'c2', score: 0.8 },
+        { holon: 'c3', score: 0.7 }
+      ]);
+
+      const result = await advisor.suggestFederations('holon', {
+        candidateHolons: ['c1', 'c2', 'c3'],
+        maxSuggestions: 2
+      });
+
+      expect(result.suggestions).toHaveLength(2);
+    });
+  });
+
+  describe('analyzeFederationHealth', () => {
+    it('should analyze federation health', async () => {
+      mockHolosphere.getFederation.mockResolvedValue({
+        federation: ['fed1', 'fed2']
+      });
+
+      mockHolosphere.getAll
+        .mockResolvedValueOnce([{ id: 1 }])
+        .mockResolvedValueOnce([]);
+
+      mockLLM.getJSON.mockResolvedValue({
+        health_score: 0.7,
+        status: 'degraded',
+        active_count: 1,
+        inactive_count: 1,
+        issues: ['One federation is inactive'],
+        recommendations: ['Reactivate fed2'],
+        summary: 'Partially healthy federation'
+      });
+
+      const result = await advisor.analyzeFederationHealth('holon1');
+
+      expect(result.holon).toBe('holon1');
+      expect(result.federation).toEqual(['fed1', 'fed2']);
+      expect(result.analysis.health_score).toBe(0.7);
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const a = new FederationAdvisor(mockLLM);
+
+      await expect(a.analyzeFederationHealth('holon'))
+        .rejects.toThrow('HoloSphere instance required');
+    });
+
+    it('should return none health if no federation configured', async () => {
+      mockHolosphere.getFederation.mockResolvedValue(null);
+
+      const result = await advisor.analyzeFederationHealth('holon1');
+
+      expect(result.health).toBe('none');
+      expect(result.score).toBe(0);
+    });
+
+    it('should return none health for empty federation array', async () => {
+      mockHolosphere.getFederation.mockResolvedValue({ federation: [] });
+
+      const result = await advisor.analyzeFederationHealth('holon1');
+
+      expect(result.health).toBe('none');
+    });
+
+    it('should handle federation partner errors', async () => {
+      mockHolosphere.getFederation.mockResolvedValue({
+        federation: ['fed1']
+      });
+
+      mockHolosphere.getAll.mockRejectedValue(new Error('Connection failed'));
+
+      mockLLM.getJSON.mockResolvedValue({
+        health_score: 0.3,
+        status: 'unhealthy'
+      });
+
+      const result = await advisor.analyzeFederationHealth('holon1');
+
+      expect(result.analysis).toBeDefined();
+    });
+  });
+
+  describe('optimizeFederation', () => {
+    it('should suggest federation optimizations', async () => {
+      mockHolosphere.getFederation.mockResolvedValue({
+        federation: ['fed1']
+      });
+
+      mockHolosphere.getAll.mockResolvedValue([{ id: 1 }]);
+
+      mockLLM.getJSON
+        .mockResolvedValueOnce({
+          health_score: 0.7,
+          status: 'degraded'
+        })
+        .mockResolvedValueOnce({
+          strengthen: ['fed1'],
+          reconsider: [],
+          new_potential: ['Similar region nearby'],
+          improvements: ['Increase sync frequency'],
+          priority: 'medium'
+        });
+
+      const result = await advisor.optimizeFederation('holon1');
+
+      expect(result.strengthen).toBeDefined();
+      expect(result.improvements).toBeDefined();
+    });
+
+    it('should return initial suggestion for no federation', async () => {
+      mockHolosphere.getFederation.mockResolvedValue(null);
+
+      const result = await advisor.optimizeFederation('holon1');
+
+      expect(result.suggestions).toContain('Consider establishing initial federations');
+    });
+  });
+
+  describe('analyzeDataFlow', () => {
+    it('should analyze data flow patterns', async () => {
+      mockHolosphere.getFederation.mockResolvedValue({
+        federation: ['fed1', 'fed2'],
+        notify: ['notify1']
+      });
+
+      mockLLM.getJSON.mockResolvedValue({
+        flow_type: 'mixed',
+        topology: 'hub',
+        propagation_depth: 2,
+        bottlenecks: ['Central hub overload'],
+        recommendations: ['Add redundant paths']
+      });
+
+      const result = await advisor.analyzeDataFlow('holon1');
+
+      expect(result.flow_type).toBe('mixed');
+      expect(result.topology).toBe('hub');
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const a = new FederationAdvisor(mockLLM);
+
+      await expect(a.analyzeDataFlow('holon'))
+        .rejects.toThrow('HoloSphere instance required');
+    });
+
+    it('should return message if no federation', async () => {
+      mockHolosphere.getFederation.mockResolvedValue(null);
+
+      const result = await advisor.analyzeDataFlow('holon1');
+
+      expect(result.message).toBe('No federation configured');
+    });
+  });
+
+  describe('findBridges', () => {
+    it('should find bridge holons in network', async () => {
+      mockHolosphere.getFederation
+        .mockResolvedValueOnce({ federation: ['h2'], notify: [] })
+        .mockResolvedValueOnce({ federation: ['h1', 'h3'], notify: [] })
+        .mockResolvedValueOnce({ federation: ['h2'], notify: [] });
+
+      mockLLM.getJSON.mockResolvedValue({
+        bridges: [{ holon: 'h2', connects: ['cluster1', 'cluster2'] }],
+        isolated: [],
+        hubs: [{ holon: 'h2', connections: 2 }],
+        clusters: [['h1', 'h2'], ['h2', 'h3']],
+        network_health: 0.8
+      });
+
+      const result = await advisor.findBridges(['h1', 'h2', 'h3']);
+
+      expect(result.bridges).toBeDefined();
+      expect(result.bridges[0].holon).toBe('h2');
+    });
+
+    it('should throw error if HoloSphere not available', async () => {
+      const a = new FederationAdvisor(mockLLM);
+
+      await expect(a.findBridges(['h1']))
+        .rejects.toThrow('HoloSphere instance required');
+    });
+
+    it('should skip holons with errors', async () => {
+      mockHolosphere.getFederation
+        .mockResolvedValueOnce({ federation: ['h2'] })
+        .mockRejectedValueOnce(new Error('Not found'));
+
+      mockLLM.getJSON.mockResolvedValue({
+        bridges: [],
+        isolated: ['h1'],
+        hubs: [],
+        clusters: [],
+        network_health: 0.5
+      });
+
+      const result = await advisor.findBridges(['h1', 'h2']);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should limit holons analyzed', async () => {
+      const manyHolons = Array(30).fill('').map((_, i) => `h${i}`);
+      mockHolosphere.getFederation.mockResolvedValue({ federation: [] });
+      mockLLM.getJSON.mockResolvedValue({ bridges: [] });
+
+      await advisor.findBridges(manyHolons);
+
+      // Should only query first 20 holons
+      expect(mockHolosphere.getFederation.mock.calls.length).toBeLessThanOrEqual(20);
+    });
+  });
+});