@bernierllc/chat-suite 1.0.0

package/__tests__/integration/ChatSuite.test.ts

@@ -0,0 +1,235 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { ChatSuite } from '../../src/ChatSuite';
+import { MessagePriority } from '../../src/types';
+
+describe('ChatSuite Integration', () => {
+  describe('initialization', () => {
+    it('should initialize with default configuration', async () => {
+      const suite = new ChatSuite();
+
+      const result = await suite.initialize();
+
+      expect(result.success).toBe(true);
+      expect(result.providersInitialized).toContain('chatkit');
+      expect(suite.isInitialized()).toBe(true);
+    });
+
+    it('should initialize with custom configuration', async () => {
+      const suite = new ChatSuite({
+        analytics: { enabled: false }
+      });
+
+      const result = await suite.initialize();
+
+      expect(result.success).toBe(true);
+      expect(result.analyticsEnabled).toBe(false);
+    });
+
+    it('should not connect to NeverHub when disabled', async () => {
+      const suite = new ChatSuite({
+        neverhub: { enabled: false, serviceName: '', capabilities: [], dependencies: [] }
+      });
+
+      await suite.initialize();
+
+      expect(suite.isNeverHubConnected()).toBe(false);
+    });
+  });
+
+  describe('message operations', () => {
+    let suite: ChatSuite;
+
+    beforeEach(async () => {
+      suite = new ChatSuite();
+      await suite.initialize();
+    });
+
+    afterEach(async () => {
+      await suite.shutdown();
+    });
+
+    it('should send a message through ChatKit', async () => {
+      const result = await suite.sendMessage('chatkit', {
+        content: 'Test message',
+        userId: 'user123'
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.provider).toBe('chatkit');
+    });
+
+    it('should broadcast a message', async () => {
+      const result = await suite.broadcastMessage({
+        content: 'Broadcast test',
+        platforms: ['chatkit'],
+        priority: MessagePriority.HIGH
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+    });
+
+    it('should fail to send when not initialized', async () => {
+      const uninitializedSuite = new ChatSuite();
+
+      const result = await uninitializedSuite.sendMessage('chatkit', {
+        content: 'Test'
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not initialized');
+    });
+  });
+
+  describe('health monitoring', () => {
+    let suite: ChatSuite;
+
+    beforeEach(async () => {
+      suite = new ChatSuite();
+      await suite.initialize();
+    });
+
+    afterEach(async () => {
+      await suite.shutdown();
+    });
+
+    it('should report health status', async () => {
+      const health = await suite.getHealth();
+
+      expect(health.status).toBeDefined();
+      expect(health.providers).toBeDefined();
+      expect(health.timestamp).toBeInstanceOf(Date);
+    });
+
+    it('should include provider health information', async () => {
+      const health = await suite.getHealth();
+
+      expect(health.providers.chatkit).toBeDefined();
+      expect(health.providers.chatkit.status).toBeDefined();
+    });
+  });
+
+  describe('user management', () => {
+    let suite: ChatSuite;
+
+    beforeEach(async () => {
+      suite = new ChatSuite();
+      await suite.initialize();
+    });
+
+    afterEach(async () => {
+      await suite.shutdown();
+    });
+
+    it('should provide access to user manager', () => {
+      const userManager = suite.getUserManager();
+
+      expect(userManager).toBeDefined();
+      expect(typeof userManager.registerUser).toBe('function');
+    });
+
+    it('should register and retrieve users', () => {
+      const userManager = suite.getUserManager();
+
+      const result = userManager.registerUser({
+        provider: 'chatkit',
+        platformUserId: 'user123',
+        displayName: 'Test User'
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.displayName).toBe('Test User');
+    });
+  });
+
+  describe('configuration management', () => {
+    let suite: ChatSuite;
+
+    beforeEach(async () => {
+      suite = new ChatSuite();
+      await suite.initialize();
+    });
+
+    afterEach(async () => {
+      await suite.shutdown();
+    });
+
+    it('should provide access to config manager', () => {
+      const configManager = suite.getConfigManager();
+
+      expect(configManager).toBeDefined();
+      expect(typeof configManager.getConfig).toBe('function');
+    });
+
+    it('should allow configuration updates', () => {
+      const configManager = suite.getConfigManager();
+
+      configManager.updateConfig({
+        analytics: { enabled: false }
+      });
+
+      const config = configManager.getConfig();
+      expect(config.analytics?.enabled).toBe(false);
+    });
+  });
+
+  describe('lifecycle management', () => {
+    it('should shutdown gracefully', async () => {
+      const suite = new ChatSuite();
+      await suite.initialize();
+
+      expect(suite.isInitialized()).toBe(true);
+
+      await suite.shutdown();
+
+      expect(suite.isInitialized()).toBe(false);
+    });
+
+    it('should allow reinitialization after shutdown', async () => {
+      const suite = new ChatSuite();
+      await suite.initialize();
+      await suite.shutdown();
+
+      const result = await suite.initialize();
+
+      expect(result.success).toBe(true);
+      expect(suite.isInitialized()).toBe(true);
+
+      await suite.shutdown();
+    });
+  });
+
+  describe('provider management', () => {
+    let suite: ChatSuite;
+
+    beforeEach(async () => {
+      suite = new ChatSuite();
+      await suite.initialize();
+    });
+
+    afterEach(async () => {
+      await suite.shutdown();
+    });
+
+    it('should provide access to provider manager', () => {
+      const providerManager = suite.getProviderManager();
+
+      expect(providerManager).toBeDefined();
+      expect(typeof providerManager.getProvider).toBe('function');
+    });
+
+    it('should have ChatKit provider initialized', () => {
+      const providerManager = suite.getProviderManager();
+      const isInitialized = providerManager.isInitialized('chatkit');
+
+      expect(isInitialized).toBe(true);
+    });
+  });
+});

package/__tests__/unit/ConfigManager.test.ts

@@ -0,0 +1,122 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { ConfigManager } from '../../src/services/ConfigManager';
+import { ChatSuiteError } from '../../src/utils/error-handling';
+
+describe('ConfigManager', () => {
+  describe('initialization', () => {
+    it('should initialize with default configuration', () => {
+      const manager = new ConfigManager();
+      const config = manager.getConfig();
+
+      expect(config.enabled).toBe(true);
+      expect(config.providers.chatkit?.enabled).toBe(true);
+    });
+
+    it('should merge custom configuration with defaults', () => {
+      const manager = new ConfigManager({
+        aiRouting: { enabled: false }
+      });
+
+      const config = manager.getConfig();
+      expect(config.aiRouting?.enabled).toBe(false);
+      expect(config.providers.chatkit?.enabled).toBe(true);
+    });
+
+    it('should throw error for invalid configuration', () => {
+      expect(() => {
+        new ConfigManager({
+          providers: {} // No providers enabled
+        });
+      }).toThrow(ChatSuiteError);
+    });
+  });
+
+  describe('configuration updates', () => {
+    it('should update configuration', () => {
+      const manager = new ConfigManager();
+
+      manager.updateConfig({
+        analytics: { enabled: false }
+      });
+
+      expect(manager.get('analytics')?.enabled).toBe(false);
+    });
+
+    it('should validate configuration on update', () => {
+      const manager = new ConfigManager();
+
+      expect(() => {
+        manager.updateConfig({
+          providers: {} // Invalid: no providers
+        });
+      }).toThrow(ChatSuiteError);
+    });
+  });
+
+  describe('overrides', () => {
+    it('should set and get overrides', () => {
+      const manager = new ConfigManager();
+
+      manager.setOverride('customKey', 'customValue');
+      expect(manager.getOverride('customKey')).toBe('customValue');
+    });
+
+    it('should clear overrides', () => {
+      const manager = new ConfigManager();
+
+      manager.setOverride('key1', 'value1');
+      manager.setOverride('key2', 'value2');
+      manager.clearOverrides();
+
+      expect(manager.getOverride('key1')).toBeUndefined();
+      expect(manager.getOverride('key2')).toBeUndefined();
+    });
+  });
+
+  describe('JSON serialization', () => {
+    it('should export configuration as JSON', () => {
+      const manager = new ConfigManager();
+      const json = manager.toJSON();
+
+      expect(() => JSON.parse(json)).not.toThrow();
+    });
+
+    it('should import configuration from JSON', () => {
+      const manager = new ConfigManager();
+      const json = JSON.stringify({
+        analytics: { enabled: false }
+      });
+
+      manager.fromJSON(json);
+      expect(manager.get('analytics')?.enabled).toBe(false);
+    });
+
+    it('should throw error for invalid JSON', () => {
+      const manager = new ConfigManager();
+
+      expect(() => {
+        manager.fromJSON('invalid json');
+      }).toThrow(ChatSuiteError);
+    });
+  });
+
+  describe('reset', () => {
+    it('should reset to default configuration', () => {
+      const manager = new ConfigManager({
+        analytics: { enabled: false }
+      });
+
+      manager.reset();
+
+      const config = manager.getConfig();
+      expect(config.analytics?.enabled).toBe(true);
+    });
+  });
+});

package/__tests__/unit/MessageOrchestrator.test.ts

@@ -0,0 +1,223 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { MessageOrchestrator } from '../../src/services/MessageOrchestrator';
+import { MessagePriority, MessageStatus } from '../../src/types';
+import type { Provider, ProviderMessage } from '../../src/types';
+
+// Mock provider for testing
+class MockProvider implements Provider {
+  public readonly type = 'chatkit' as const;
+  public readonly name = 'mock-provider';
+  private _initialized = false;
+
+  public async initialize(): Promise<void> {
+    this._initialized = true;
+  }
+
+  public isInitialized(): boolean {
+    return this._initialized;
+  }
+
+  public async sendMessage(message: ProviderMessage) {
+    return {
+      success: true,
+      messageId: 'msg123',
+      timestamp: new Date(),
+      provider: this.type
+    };
+  }
+
+  public async getHealth() {
+    return {
+      status: 'healthy' as const,
+      lastCheck: new Date(),
+      errorCount: 0
+    };
+  }
+
+  public async shutdown(): Promise<void> {
+    this._initialized = false;
+  }
+}
+
+describe('MessageOrchestrator', () => {
+  let orchestrator: MessageOrchestrator;
+  let mockProvider: MockProvider;
+
+  beforeEach(async () => {
+    orchestrator = new MessageOrchestrator();
+    mockProvider = new MockProvider();
+    await mockProvider.initialize();
+  });
+
+  describe('message sending', () => {
+    it('should send a message through a provider', async () => {
+      const result = await orchestrator.sendMessage(mockProvider, {
+        content: 'Test message'
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.messageId).toBe('msg123');
+    });
+
+    it('should fail if provider not initialized', async () => {
+      const uninitializedProvider = new MockProvider();
+
+      const result = await orchestrator.sendMessage(uninitializedProvider, {
+        content: 'Test message'
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not initialized');
+    });
+  });
+
+  describe('message broadcasting', () => {
+    it('should broadcast to multiple providers', async () => {
+      const providers = new Map();
+      providers.set('chatkit', mockProvider);
+
+      const result = await orchestrator.broadcastMessage(providers, {
+        content: 'Broadcast message',
+        platforms: ['chatkit']
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toHaveLength(1);
+    });
+
+    it('should fail if no valid providers', async () => {
+      const result = await orchestrator.broadcastMessage(
+        new Map(),
+        {
+          content: 'Test',
+          platforms: ['slack']
+        }
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('No valid providers');
+    });
+  });
+
+  describe('message tracking', () => {
+    it('should track broadcast messages', async () => {
+      const providers = new Map();
+      providers.set('chatkit', mockProvider);
+
+      await orchestrator.broadcastMessage(providers, {
+        content: 'Test',
+        platforms: ['chatkit'],
+        priority: MessagePriority.HIGH
+      });
+
+      const messages = orchestrator.getAllMessages();
+      expect(messages.length).toBeGreaterThan(0);
+      expect(messages[0].priority).toBe(MessagePriority.HIGH);
+    });
+
+    it('should get message by ID', async () => {
+      const providers = new Map();
+      providers.set('chatkit', mockProvider);
+
+      await orchestrator.broadcastMessage(providers, {
+        content: 'Test',
+        platforms: ['chatkit']
+      });
+
+      const messages = orchestrator.getAllMessages();
+      const messageId = messages[0].id;
+
+      const retrieved = orchestrator.getMessage(messageId);
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe(messageId);
+    });
+
+    it('should filter messages by status', async () => {
+      const providers = new Map();
+      providers.set('chatkit', mockProvider);
+
+      await orchestrator.broadcastMessage(providers, {
+        content: 'Test',
+        platforms: ['chatkit']
+      });
+
+      const sentMessages = orchestrator.getMessagesByStatus(MessageStatus.SENT);
+      expect(sentMessages.length).toBeGreaterThan(0);
+    });
+
+    it('should update message status', async () => {
+      const providers = new Map();
+      providers.set('chatkit', mockProvider);
+
+      await orchestrator.broadcastMessage(providers, {
+        content: 'Test',
+        platforms: ['chatkit']
+      });
+
+      const messages = orchestrator.getAllMessages();
+      const messageId = messages[0].id;
+
+      const updated = orchestrator.updateMessageStatus(messageId, MessageStatus.FAILED);
+      expect(updated).toBe(true);
+
+      const message = orchestrator.getMessage(messageId);
+      expect(message?.status).toBe(MessageStatus.FAILED);
+    });
+  });
+
+  describe('statistics', () => {
+    it('should provide message statistics', async () => {
+      const providers = new Map();
+      providers.set('chatkit', mockProvider);
+
+      await orchestrator.broadcastMessage(providers, {
+        content: 'Test 1',
+        platforms: ['chatkit'],
+        priority: MessagePriority.HIGH
+      });
+
+      await orchestrator.broadcastMessage(providers, {
+        content: 'Test 2',
+        platforms: ['chatkit'],
+        priority: MessagePriority.NORMAL
+      });
+
+      const stats = orchestrator.getStats();
+      expect(stats.total).toBe(2);
+      expect(stats.byPriority[MessagePriority.HIGH]).toBe(1);
+      expect(stats.byPriority[MessagePriority.NORMAL]).toBe(1);
+    });
+
+    it('should get message count', async () => {
+      const providers = new Map();
+      providers.set('chatkit', mockProvider);
+
+      await orchestrator.broadcastMessage(providers, {
+        content: 'Test',
+        platforms: ['chatkit']
+      });
+
+      expect(orchestrator.getMessageCount()).toBe(1);
+    });
+
+    it('should clear messages', async () => {
+      const providers = new Map();
+      providers.set('chatkit', mockProvider);
+
+      await orchestrator.broadcastMessage(providers, {
+        content: 'Test',
+        platforms: ['chatkit']
+      });
+
+      orchestrator.clearMessages();
+      expect(orchestrator.getMessageCount()).toBe(0);
+    });
+  });
+});