holosphere 2.0.0-alpha1 → 2.0.0-alpha10

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

@@ -1,344 +0,0 @@
-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);
-    });
-  });
-});