n8n-MCP

import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'; import { TelemetryManager, telemetry } from '../../../src/telemetry/telemetry-manager'; import { TelemetryConfigManager } from '../../../src/telemetry/config-manager'; import { TelemetryEventTracker } from '../../../src/telemetry/event-tracker'; import { TelemetryBatchProcessor } from '../../../src/telemetry/batch-processor'; import { createClient } from '@supabase/supabase-js'; import { TELEMETRY_BACKEND } from '../../../src/telemetry/telemetry-types'; import { TelemetryError, TelemetryErrorType } from '../../../src/telemetry/telemetry-error'; // Mock all dependencies vi.mock('../../../src/utils/logger', () => ({ logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn(), } })); vi.mock('@supabase/supabase-js', () => ({ createClient: vi.fn() })); vi.mock('../../../src/telemetry/config-manager'); vi.mock('../../../src/telemetry/event-tracker'); vi.mock('../../../src/telemetry/batch-processor'); vi.mock('../../../src/telemetry/workflow-sanitizer'); describe('TelemetryManager', () => { let mockConfigManager: any; let mockSupabaseClient: any; let mockEventTracker: any; let mockBatchProcessor: any; let manager: TelemetryManager; beforeEach(() => { // Reset singleton using the new method TelemetryManager.resetInstance(); // Mock TelemetryConfigManager mockConfigManager = { isEnabled: vi.fn().mockReturnValue(true), getUserId: vi.fn().mockReturnValue('test-user-123'), disable: vi.fn(), enable: vi.fn(), getStatus: vi.fn().mockReturnValue('enabled') }; vi.mocked(TelemetryConfigManager.getInstance).mockReturnValue(mockConfigManager); // Mock Supabase client mockSupabaseClient = { from: vi.fn().mockReturnValue({ insert: vi.fn().mockResolvedValue({ data: null, error: null }) }) }; vi.mocked(createClient).mockReturnValue(mockSupabaseClient); // Mock EventTracker mockEventTracker = { trackToolUsage: vi.fn(), trackWorkflowCreation: vi.fn().mockResolvedValue(undefined), trackError: vi.fn(), trackEvent: vi.fn(), trackSessionStart: vi.fn(), trackSearchQuery: vi.fn(), trackValidationDetails: vi.fn(), trackToolSequence: vi.fn(), trackNodeConfiguration: vi.fn(), trackPerformanceMetric: vi.fn(), updateToolSequence: vi.fn(), getEventQueue: vi.fn().mockReturnValue([]), getWorkflowQueue: vi.fn().mockReturnValue([]), clearEventQueue: vi.fn(), clearWorkflowQueue: vi.fn(), getStats: vi.fn().mockReturnValue({ rateLimiter: { currentEvents: 0, droppedEvents: 0 }, validator: { successes: 0, errors: 0 }, eventQueueSize: 0, workflowQueueSize: 0, performanceMetrics: {} }) }; vi.mocked(TelemetryEventTracker).mockImplementation(() => mockEventTracker); // Mock BatchProcessor mockBatchProcessor = { start: vi.fn(), stop: vi.fn(), flush: vi.fn().mockResolvedValue(undefined), getMetrics: vi.fn().mockReturnValue({ eventsTracked: 0, eventsDropped: 0, eventsFailed: 0, batchesSent: 0, batchesFailed: 0, averageFlushTime: 0, rateLimitHits: 0, circuitBreakerState: { state: 'closed', failureCount: 0, canRetry: true }, deadLetterQueueSize: 0 }), resetMetrics: vi.fn() }; vi.mocked(TelemetryBatchProcessor).mockImplementation(() => mockBatchProcessor); vi.clearAllMocks(); }); afterEach(() => { // Clean up global state TelemetryManager.resetInstance(); }); describe('singleton behavior', () => { it('should create only one instance', () => { const instance1 = TelemetryManager.getInstance(); const instance2 = TelemetryManager.getInstance(); expect(instance1).toBe(instance2); }); it.skip('should use global singleton for telemetry export', async () => { // Skip: Testing module import behavior with mocks is complex // The core singleton behavior is tested in other tests const instance = TelemetryManager.getInstance(); // Import the telemetry export const { telemetry: telemetry1 } = await import('../../../src/telemetry/telemetry-manager'); // Both should reference the same global singleton expect(telemetry1).toBe(instance); }); }); describe('initialization', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); }); it('should initialize successfully when enabled', () => { // Trigger initialization by calling a tracking method manager.trackEvent('test', {}); expect(mockConfigManager.isEnabled).toHaveBeenCalled(); expect(createClient).toHaveBeenCalledWith( TELEMETRY_BACKEND.URL, TELEMETRY_BACKEND.ANON_KEY, expect.objectContaining({ auth: { persistSession: false, autoRefreshToken: false } }) ); expect(mockBatchProcessor.start).toHaveBeenCalled(); }); it('should use environment variables if provided', () => { process.env.SUPABASE_URL = 'https://custom.supabase.co'; process.env.SUPABASE_ANON_KEY = 'custom-anon-key'; // Reset instance to trigger re-initialization TelemetryManager.resetInstance(); manager = TelemetryManager.getInstance(); // Trigger initialization manager.trackEvent('test', {}); expect(createClient).toHaveBeenCalledWith( 'https://custom.supabase.co', 'custom-anon-key', expect.any(Object) ); // Clean up delete process.env.SUPABASE_URL; delete process.env.SUPABASE_ANON_KEY; }); it('should not initialize when disabled', () => { mockConfigManager.isEnabled.mockReturnValue(false); // Reset instance to trigger re-initialization TelemetryManager.resetInstance(); manager = TelemetryManager.getInstance(); expect(createClient).not.toHaveBeenCalled(); expect(mockBatchProcessor.start).not.toHaveBeenCalled(); }); it('should handle initialization errors', () => { vi.mocked(createClient).mockImplementation(() => { throw new Error('Supabase initialization failed'); }); // Reset instance to trigger re-initialization TelemetryManager.resetInstance(); manager = TelemetryManager.getInstance(); expect(mockBatchProcessor.start).not.toHaveBeenCalled(); }); }); describe('event tracking methods', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); }); it('should track tool usage with sequence update', () => { manager.trackToolUsage('httpRequest', true, 500); expect(mockEventTracker.trackToolUsage).toHaveBeenCalledWith('httpRequest', true, 500); expect(mockEventTracker.updateToolSequence).toHaveBeenCalledWith('httpRequest'); }); it('should track workflow creation and auto-flush', async () => { const workflow = { nodes: [], connections: {} }; await manager.trackWorkflowCreation(workflow, true); expect(mockEventTracker.trackWorkflowCreation).toHaveBeenCalledWith(workflow, true); expect(mockBatchProcessor.flush).toHaveBeenCalled(); }); it('should handle workflow creation errors', async () => { const workflow = { nodes: [], connections: {} }; const error = new Error('Workflow tracking failed'); mockEventTracker.trackWorkflowCreation.mockRejectedValue(error); await manager.trackWorkflowCreation(workflow, true); // Should not throw, but should handle error internally expect(mockEventTracker.trackWorkflowCreation).toHaveBeenCalledWith(workflow, true); }); it('should track errors', () => { manager.trackError('ValidationError', 'Node configuration invalid', 'httpRequest', 'Required field "url" is missing'); expect(mockEventTracker.trackError).toHaveBeenCalledWith( 'ValidationError', 'Node configuration invalid', 'httpRequest', 'Required field "url" is missing' ); }); it('should track generic events', () => { const properties = { key: 'value', count: 42 }; manager.trackEvent('custom_event', properties); expect(mockEventTracker.trackEvent).toHaveBeenCalledWith('custom_event', properties); }); it('should track session start', () => { manager.trackSessionStart(); expect(mockEventTracker.trackSessionStart).toHaveBeenCalled(); }); it('should track search queries', () => { manager.trackSearchQuery('httpRequest nodes', 5, 'nodes'); expect(mockEventTracker.trackSearchQuery).toHaveBeenCalledWith( 'httpRequest nodes', 5, 'nodes' ); }); it('should track validation details', () => { const details = { field: 'url', value: 'invalid' }; manager.trackValidationDetails('nodes-base.httpRequest', 'required_field_missing', details); expect(mockEventTracker.trackValidationDetails).toHaveBeenCalledWith( 'nodes-base.httpRequest', 'required_field_missing', details ); }); it('should track tool sequences', () => { manager.trackToolSequence('httpRequest', 'webhook', 5000); expect(mockEventTracker.trackToolSequence).toHaveBeenCalledWith( 'httpRequest', 'webhook', 5000 ); }); it('should track node configuration', () => { manager.trackNodeConfiguration('nodes-base.httpRequest', 5, false); expect(mockEventTracker.trackNodeConfiguration).toHaveBeenCalledWith( 'nodes-base.httpRequest', 5, false ); }); it('should track performance metrics', () => { const metadata = { operation: 'database_query' }; manager.trackPerformanceMetric('search_nodes', 1500, metadata); expect(mockEventTracker.trackPerformanceMetric).toHaveBeenCalledWith( 'search_nodes', 1500, metadata ); }); }); describe('flush()', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); }); it('should flush events and workflows', async () => { const mockEvents = [{ user_id: 'user1', event: 'test', properties: {} }]; const mockWorkflows = [{ user_id: 'user1', workflow_hash: 'hash1' }]; mockEventTracker.getEventQueue.mockReturnValue(mockEvents); mockEventTracker.getWorkflowQueue.mockReturnValue(mockWorkflows); await manager.flush(); expect(mockEventTracker.getEventQueue).toHaveBeenCalled(); expect(mockEventTracker.getWorkflowQueue).toHaveBeenCalled(); expect(mockEventTracker.clearEventQueue).toHaveBeenCalled(); expect(mockEventTracker.clearWorkflowQueue).toHaveBeenCalled(); expect(mockBatchProcessor.flush).toHaveBeenCalledWith(mockEvents, mockWorkflows); }); it('should not flush when disabled', async () => { mockConfigManager.isEnabled.mockReturnValue(false); await manager.flush(); expect(mockBatchProcessor.flush).not.toHaveBeenCalled(); }); it('should not flush without Supabase client', async () => { // Simulate initialization failure vi.mocked(createClient).mockImplementation(() => { throw new Error('Init failed'); }); // Reset instance to trigger re-initialization with failure (TelemetryManager as any).instance = undefined; manager = TelemetryManager.getInstance(); await manager.flush(); expect(mockBatchProcessor.flush).not.toHaveBeenCalled(); }); it('should handle flush errors gracefully', async () => { const error = new Error('Flush failed'); mockBatchProcessor.flush.mockRejectedValue(error); await manager.flush(); // Should not throw, error should be handled internally expect(mockBatchProcessor.flush).toHaveBeenCalled(); }); it('should handle TelemetryError specifically', async () => { const telemetryError = new TelemetryError( TelemetryErrorType.NETWORK_ERROR, 'Network failed', { attempt: 1 }, true ); mockBatchProcessor.flush.mockRejectedValue(telemetryError); await manager.flush(); expect(mockBatchProcessor.flush).toHaveBeenCalled(); }); }); describe('enable/disable functionality', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); }); it('should disable telemetry', () => { manager.disable(); expect(mockConfigManager.disable).toHaveBeenCalled(); expect(mockBatchProcessor.stop).toHaveBeenCalled(); }); it('should enable telemetry', () => { // Disable first to clear state manager.disable(); vi.clearAllMocks(); // Now enable manager.enable(); expect(mockConfigManager.enable).toHaveBeenCalled(); // Should initialize (createClient called once) expect(createClient).toHaveBeenCalledTimes(1); }); it('should get status from config manager', () => { const status = manager.getStatus(); expect(mockConfigManager.getStatus).toHaveBeenCalled(); expect(status).toBe('enabled'); }); }); describe('getMetrics()', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); // Trigger initialization for enabled tests manager.trackEvent('test', {}); }); it('should return comprehensive metrics when enabled', () => { const metrics = manager.getMetrics(); expect(metrics).toEqual({ status: 'enabled', initialized: true, tracking: expect.any(Object), processing: expect.any(Object), errors: expect.any(Object), performance: expect.any(Object), overhead: expect.any(Object) }); expect(mockEventTracker.getStats).toHaveBeenCalled(); expect(mockBatchProcessor.getMetrics).toHaveBeenCalled(); }); it('should return disabled status when disabled', () => { mockConfigManager.isEnabled.mockReturnValue(false); // Reset to get a fresh instance without initialization TelemetryManager.resetInstance(); manager = TelemetryManager.getInstance(); const metrics = manager.getMetrics(); expect(metrics.status).toBe('disabled'); expect(metrics.initialized).toBe(false); // Not initialized when disabled }); it('should reflect initialization failure', () => { // Simulate initialization failure vi.mocked(createClient).mockImplementation(() => { throw new Error('Init failed'); }); // Reset instance to trigger re-initialization with failure (TelemetryManager as any).instance = undefined; manager = TelemetryManager.getInstance(); const metrics = manager.getMetrics(); expect(metrics.initialized).toBe(false); }); }); describe('error handling and aggregation', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); }); it('should aggregate initialization errors', () => { vi.mocked(createClient).mockImplementation(() => { throw new Error('Supabase connection failed'); }); // Reset instance to trigger re-initialization with error TelemetryManager.resetInstance(); manager = TelemetryManager.getInstance(); // Trigger initialization which will fail manager.trackEvent('test', {}); const metrics = manager.getMetrics(); expect(metrics.errors.totalErrors).toBeGreaterThan(0); }); it('should aggregate workflow tracking errors', async () => { const error = new TelemetryError( TelemetryErrorType.VALIDATION_ERROR, 'Workflow validation failed' ); mockEventTracker.trackWorkflowCreation.mockRejectedValue(error); const workflow = { nodes: [], connections: {} }; await manager.trackWorkflowCreation(workflow, true); const metrics = manager.getMetrics(); expect(metrics.errors.totalErrors).toBeGreaterThan(0); }); it('should aggregate flush errors', async () => { const error = new Error('Network timeout'); mockBatchProcessor.flush.mockRejectedValue(error); await manager.flush(); const metrics = manager.getMetrics(); expect(metrics.errors.totalErrors).toBeGreaterThan(0); }); }); describe('constructor privacy', () => { it('should have private constructor', () => { // Ensure there's already an instance TelemetryManager.getInstance(); // Now trying to instantiate directly should throw expect(() => new (TelemetryManager as any)()).toThrow('Use TelemetryManager.getInstance() instead of new TelemetryManager()'); }); }); describe('isEnabled() privacy', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); }); it('should correctly check enabled state', async () => { mockConfigManager.isEnabled.mockReturnValue(true); await manager.flush(); expect(mockBatchProcessor.flush).toHaveBeenCalled(); }); it('should prevent operations when not initialized', async () => { // Simulate initialization failure vi.mocked(createClient).mockImplementation(() => { throw new Error('Init failed'); }); // Reset instance to trigger re-initialization with failure (TelemetryManager as any).instance = undefined; manager = TelemetryManager.getInstance(); await manager.flush(); expect(mockBatchProcessor.flush).not.toHaveBeenCalled(); }); }); describe('dependency injection and callbacks', () => { it('should provide correct callbacks to EventTracker', () => { const TelemetryEventTrackerMock = vi.mocked(TelemetryEventTracker); const manager = TelemetryManager.getInstance(); // Trigger initialization manager.trackEvent('test', {}); expect(TelemetryEventTrackerMock).toHaveBeenCalledWith( expect.any(Function), // getUserId callback expect.any(Function) // isEnabled callback ); // Test the callbacks const [getUserIdCallback, isEnabledCallback] = TelemetryEventTrackerMock.mock.calls[0]; expect(getUserIdCallback()).toBe('test-user-123'); expect(isEnabledCallback()).toBe(true); }); it('should provide correct callbacks to BatchProcessor', () => { const TelemetryBatchProcessorMock = vi.mocked(TelemetryBatchProcessor); const manager = TelemetryManager.getInstance(); // Trigger initialization manager.trackEvent('test', {}); expect(TelemetryBatchProcessorMock).toHaveBeenCalledTimes(2); // Once with null, once with Supabase client const lastCall = TelemetryBatchProcessorMock.mock.calls[TelemetryBatchProcessorMock.mock.calls.length - 1]; const [supabaseClient, isEnabledCallback] = lastCall; expect(supabaseClient).toBe(mockSupabaseClient); expect(isEnabledCallback()).toBe(true); }); }); describe('Supabase client configuration', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); // Trigger initialization manager.trackEvent('test', {}); }); it('should configure Supabase client with correct options', () => { expect(createClient).toHaveBeenCalledWith( TELEMETRY_BACKEND.URL, TELEMETRY_BACKEND.ANON_KEY, { auth: { persistSession: false, autoRefreshToken: false }, realtime: { params: { eventsPerSecond: 1 } } } ); }); }); describe('workflow creation auto-flush behavior', () => { beforeEach(() => { manager = TelemetryManager.getInstance(); }); it('should auto-flush after successful workflow tracking', async () => { const workflow = { nodes: [], connections: {} }; await manager.trackWorkflowCreation(workflow, true); expect(mockEventTracker.trackWorkflowCreation).toHaveBeenCalledWith(workflow, true); expect(mockBatchProcessor.flush).toHaveBeenCalled(); }); it('should not auto-flush if workflow tracking fails', async () => { const workflow = { nodes: [], connections: {} }; mockEventTracker.trackWorkflowCreation.mockRejectedValue(new Error('Tracking failed')); await manager.trackWorkflowCreation(workflow, true); expect(mockEventTracker.trackWorkflowCreation).toHaveBeenCalledWith(workflow, true); // Flush should NOT be called if tracking fails expect(mockBatchProcessor.flush).not.toHaveBeenCalled(); }); }); describe('global singleton behavior', () => { it('should preserve singleton across require() calls', async () => { // Get the first instance const manager1 = TelemetryManager.getInstance(); // Clear and re-get the instance - should be same due to global state TelemetryManager.resetInstance(); const manager2 = TelemetryManager.getInstance(); // They should be different instances after reset expect(manager2).not.toBe(manager1); // But subsequent calls should return the same instance const manager3 = TelemetryManager.getInstance(); expect(manager3).toBe(manager2); }); it.skip('should handle undefined global state gracefully', async () => { // Skip: Testing module import behavior with mocks is complex // The core singleton behavior is tested in other tests // Ensure clean state TelemetryManager.resetInstance(); const manager1 = TelemetryManager.getInstance(); expect(manager1).toBeDefined(); // Import telemetry - it should use the same global instance const { telemetry } = await import('../../../src/telemetry/telemetry-manager'); expect(telemetry).toBeDefined(); expect(telemetry).toBe(manager1); }); }); });