@onlineapps/conn-base-monitoring 1.0.0

package/test/component/integration.test.js

@@ -0,0 +1,460 @@
+/**
+ * Component tests for conn-base-monitoring integration
+ */
+
+// Mock monitoring-core for component tests
+jest.mock('@onlineapps/monitoring-core', () => {
+  // Create a fresh Map for each test to avoid state pollution
+  let mockWorkflows;
+
+  const createMockCore = async (config) => {
+    mockWorkflows = new Map();
+
+    return {
+      config,
+      logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        log: jest.fn()
+      },
+      workflow: {
+        start: jest.fn((id, type) => {
+          mockWorkflows.set(id, { type, steps: [] });
+          return id;
+        }),
+        step: jest.fn((id, name) => {
+          const wf = mockWorkflows.get(id);
+          if (wf) wf.steps.push(name);
+        }),
+        end: jest.fn((id) => {
+          mockWorkflows.delete(id);
+        }),
+        error: jest.fn((id, error, attrs) => {
+          // Handle error workflow
+        }),
+        activeWorkflows: mockWorkflows,
+        getWorkflow: jest.fn((id) => mockWorkflows.get(id))
+      },
+      createCounter: jest.fn(() => ({ add: jest.fn() })),
+      createHistogram: jest.fn(() => ({ record: jest.fn() })),
+      createMetric: jest.fn(() => ({ add: jest.fn(), record: jest.fn() })),
+      shutdown: jest.fn()
+    };
+  };
+
+  return {
+    init: jest.fn(createMockCore),
+    getInstance: jest.fn(() => null),
+    createLogger: jest.fn((config) => ({
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn()
+    })),
+    WorkflowTracker: jest.fn().mockImplementation((name) => ({
+      serviceName: name,
+      start: jest.fn(),
+      activeWorkflows: new Map()
+    }))
+  };
+});
+
+const { init } = require('../../src');
+
+describe('conn-base-monitoring Component Tests', () => {
+  let monitoring;
+
+  beforeAll(() => {
+    process.env.MONITORING_MODE = 'off';
+  });
+
+  afterEach(async () => {
+    if (monitoring && monitoring.shutdown) {
+      await monitoring.shutdown();
+    }
+  });
+
+  describe('Full Workflow Lifecycle', () => {
+    beforeEach(async () => {
+      monitoring = await init({
+        serviceName: 'component-test',
+        serviceVersion: '1.0.0',
+        mode: 'off',
+        logLevel: 'DEBUG'
+      });
+    });
+
+    test('should handle complete workflow with logging', () => {
+      const workflowId = 'comp-wf-1';
+
+      // Start workflow
+      monitoring.info(`Starting workflow ${workflowId}`);
+      monitoring.startWorkflow(workflowId, 'data-processing', {
+        source: 'api',
+        userId: 'user-123'
+      });
+
+      // Process steps
+      monitoring.stepWorkflow(workflowId, 'validation', { status: 'validating' });
+      monitoring.debug('Validating input data', { workflowId, records: 100 });
+
+      monitoring.stepWorkflow(workflowId, 'transformation', { status: 'transforming' });
+      monitoring.info('Transforming data', { workflowId, format: 'json' });
+
+      monitoring.stepWorkflow(workflowId, 'persistence', { status: 'saving' });
+      monitoring.debug('Saving to database', { workflowId, table: 'results' });
+
+      // Complete workflow
+      monitoring.endWorkflow(workflowId, 'success', {
+        duration: 1500,
+        recordsProcessed: 100
+      });
+      monitoring.info(`Workflow ${workflowId} completed successfully`);
+
+      // Workflow completed successfully - we trust internal tracking
+      expect(monitoring.workflow.activeWorkflows.has(workflowId)).toBe(false);
+    });
+
+    test('should handle workflow with errors and recovery', () => {
+      const workflowId = 'error-wf-1';
+
+      monitoring.startWorkflow(workflowId, 'risky-operation');
+      monitoring.info('Starting risky operation', { workflowId });
+
+      // Simulate error
+      const error = new Error('Database connection failed');
+      monitoring.errorWorkflow(workflowId, error, {
+        retryCount: 1,
+        maxRetries: 3
+      });
+      monitoring.error('Operation failed, retrying', {
+        workflowId,
+        error: error.message
+      });
+
+      // Retry
+      monitoring.stepWorkflow(workflowId, 'retry-1', { attempt: 2 });
+      monitoring.warn('Retrying operation', { workflowId, attempt: 2 });
+
+      // Success after retry
+      monitoring.endWorkflow(workflowId, 'recovered', {
+        totalAttempts: 2
+      });
+      monitoring.info('Operation recovered after retry', { workflowId });
+
+      expect(monitoring.workflow.activeWorkflows.has(workflowId)).toBe(false);
+    });
+  });
+
+  describe('Metrics with Workflow Tracking', () => {
+    beforeEach(async () => {
+      monitoring = await init({
+        serviceName: 'metrics-workflow',
+        mode: 'light' // Enable metrics
+      });
+    });
+
+    test('should track metrics during workflow execution', () => {
+      const requestCounter = monitoring.createCounter('api.requests', {
+        description: 'API request count'
+      });
+
+      const latencyHistogram = monitoring.createHistogram('api.latency', {
+        description: 'API latency in ms',
+        unit: 'ms'
+      });
+
+      // Simulate multiple API calls
+      const workflows = [];
+      for (let i = 0; i < 5; i++) {
+        const wfId = `metric-wf-${i}`;
+        workflows.push(wfId);
+
+        monitoring.startWorkflow(wfId, 'api-call');
+        requestCounter.add(1, { endpoint: '/api/data', method: 'GET' });
+
+        // Simulate varying latencies
+        const latency = 100 + Math.random() * 200;
+        latencyHistogram.record(latency, { endpoint: '/api/data' });
+
+        monitoring.endWorkflow(wfId, 'success');
+      }
+
+      // All workflows should be completed
+      workflows.forEach(wfId => {
+        expect(monitoring.workflow.activeWorkflows.has(wfId)).toBe(false);
+      });
+    });
+
+    test('should handle error metrics', () => {
+      const errorCounter = monitoring.createCounter('errors.total', {
+        description: 'Total errors'
+      });
+
+      const errors = [
+        { type: 'ValidationError', code: 400 },
+        { type: 'DatabaseError', code: 500 },
+        { type: 'TimeoutError', code: 408 }
+      ];
+
+      errors.forEach((err, index) => {
+        const wfId = `error-metric-${index}`;
+        monitoring.startWorkflow(wfId, 'operation');
+
+        errorCounter.add(1, {
+          errorType: err.type,
+          statusCode: err.code
+        });
+
+        monitoring.error(`${err.type} occurred`, {
+          workflowId: wfId,
+          code: err.code
+        });
+
+        monitoring.errorWorkflow(wfId, new Error(err.type), {
+          statusCode: err.code
+        });
+
+        monitoring.endWorkflow(wfId, 'failed');
+      });
+
+      expect(monitoring.workflow.activeWorkflows.size).toBe(0);
+    });
+  });
+
+  describe('Concurrent Operations', () => {
+    beforeEach(async () => {
+      monitoring = await init({
+        serviceName: 'concurrent-test',
+        mode: 'off'
+      });
+    });
+
+    test('should handle multiple concurrent workflows', () => {
+      const workflows = [];
+      const concurrentCount = 10;
+
+      // Start multiple workflows
+      for (let i = 0; i < concurrentCount; i++) {
+        const wfId = `concurrent-${i}`;
+        workflows.push(wfId);
+        monitoring.startWorkflow(wfId, 'parallel-process');
+      }
+
+      expect(monitoring.workflow.activeWorkflows.size).toBe(concurrentCount);
+
+      // Process each workflow
+      workflows.forEach((wfId, index) => {
+        monitoring.stepWorkflow(wfId, 'processing', { index });
+        monitoring.info(`Processing workflow ${index}`, { workflowId: wfId });
+      });
+
+      // Complete half of them
+      const halfPoint = Math.floor(concurrentCount / 2);
+      workflows.slice(0, halfPoint).forEach(wfId => {
+        monitoring.endWorkflow(wfId, 'completed');
+      });
+
+      expect(monitoring.workflow.activeWorkflows.size).toBe(concurrentCount - halfPoint);
+
+      // Complete the rest
+      workflows.slice(halfPoint).forEach(wfId => {
+        monitoring.endWorkflow(wfId, 'completed');
+      });
+
+      expect(monitoring.workflow.activeWorkflows.size).toBe(0);
+    });
+
+    test('should handle rapid fire logging', () => {
+      const messageCount = 100;
+
+      expect(() => {
+        for (let i = 0; i < messageCount; i++) {
+          const level = ['debug', 'info', 'warn', 'error'][i % 4];
+          monitoring[level](`Message ${i}`, { index: i, level });
+        }
+      }).not.toThrow();
+    });
+  });
+
+  describe('Configuration Modes', () => {
+    test('should work in off mode (no external connections)', async () => {
+      const offMode = await init({
+        serviceName: 'off-mode-test',
+        mode: 'off'
+      });
+
+      expect(() => {
+        offMode.info('This should only console log');
+        offMode.startWorkflow('wf-off', 'test');
+        offMode.endWorkflow('wf-off', 'done');
+      }).not.toThrow();
+
+      await offMode.shutdown();
+    });
+
+    test('should work in light mode (basic telemetry)', async () => {
+      const lightMode = await init({
+        serviceName: 'light-mode-test',
+        mode: 'light'
+      });
+
+      const counter = lightMode.createCounter('light.counter');
+      expect(() => {
+        counter.add(1);
+        lightMode.info('Light mode active');
+      }).not.toThrow();
+
+      await lightMode.shutdown();
+    });
+
+    test('should work in full mode (complete telemetry)', async () => {
+      const fullMode = await init({
+        serviceName: 'full-mode-test',
+        mode: 'full'
+      });
+
+      expect(() => {
+        fullMode.startWorkflow('full-wf', 'complete');
+        fullMode.stepWorkflow('full-wf', 'step1');
+        fullMode.endWorkflow('full-wf', 'done');
+
+        const histogram = fullMode.createHistogram('full.histogram');
+        histogram.record(123.45);
+      }).not.toThrow();
+
+      await fullMode.shutdown();
+    });
+
+    test('should work in debug mode (verbose output)', async () => {
+      const debugMode = await init({
+        serviceName: 'debug-mode-test',
+        mode: 'debug',
+        logLevel: 'DEBUG'
+      });
+
+      expect(() => {
+        debugMode.debug('Debug details', { verbose: true });
+        debugMode.info('Info message');
+        debugMode.warn('Warning');
+        debugMode.error('Error');
+      }).not.toThrow();
+
+      await debugMode.shutdown();
+    });
+  });
+
+  describe('Error Handling and Edge Cases', () => {
+    beforeEach(async () => {
+      monitoring = await init({
+        serviceName: 'edge-cases',
+        mode: 'off'
+      });
+    });
+
+    test('should handle null and undefined values', () => {
+      expect(() => {
+        monitoring.info(null);
+        monitoring.info(undefined);
+        monitoring.info('Message', null);
+        monitoring.info('Message', undefined);
+      }).not.toThrow();
+    });
+
+    test('should handle circular references', () => {
+      const obj = { name: 'circular' };
+      obj.self = obj;
+
+      expect(() => {
+        monitoring.info('Circular ref', obj);
+      }).not.toThrow();
+    });
+
+    test('should handle very long messages', () => {
+      const longMessage = 'x'.repeat(10000);
+      const longData = {
+        field: 'y'.repeat(10000)
+      };
+
+      expect(() => {
+        monitoring.info(longMessage, longData);
+      }).not.toThrow();
+    });
+
+    test('should handle special characters', () => {
+      expect(() => {
+        monitoring.info('Unicode: 你好 مرحبا שלום', {
+          emoji: '🚀🎉😀',
+          special: '\n\t\r\0'
+        });
+      }).not.toThrow();
+    });
+
+    test('should handle workflow with missing steps', () => {
+      const wfId = 'incomplete-wf';
+
+      monitoring.startWorkflow(wfId, 'test');
+      // Skip steps, go directly to end
+      monitoring.endWorkflow(wfId, 'skipped');
+
+      expect(monitoring.workflow.activeWorkflows.has(wfId)).toBe(false);
+    });
+
+    test('should handle double workflow start', () => {
+      const wfId = 'double-start';
+
+      monitoring.startWorkflow(wfId, 'first');
+      monitoring.startWorkflow(wfId, 'second'); // Should replace
+
+      const workflow = monitoring.workflow.getWorkflow(wfId);
+      expect(workflow.type).toBe('second');
+
+      monitoring.endWorkflow(wfId, 'done');
+    });
+  });
+
+  describe('Memory and Resource Management', () => {
+    beforeEach(async () => {
+      // Create fresh monitoring instance for memory tests
+      monitoring = await init({
+        serviceName: 'memory-test',
+        mode: 'off'
+      });
+    });
+
+    test('should not leak memory with many workflows', async () => {
+      const iterations = 100;
+
+      for (let i = 0; i < iterations; i++) {
+        const wfId = `mem-test-${i}`;
+        monitoring.startWorkflow(wfId, 'memory-test');
+        monitoring.stepWorkflow(wfId, 'process');
+        monitoring.endWorkflow(wfId, 'done');
+      }
+
+      expect(monitoring.workflow.activeWorkflows.size).toBe(0);
+    });
+
+    test('should handle rapid instance creation', async () => {
+      const instances = [];
+
+      for (let i = 0; i < 10; i++) {
+        const instance = await init({
+          serviceName: `rapid-${i}`,
+          mode: 'off'
+        });
+        instances.push(instance);
+      }
+
+      // All instances should be independent
+      expect(instances[0]).not.toBe(instances[1]);
+
+      // Cleanup
+      for (const instance of instances) {
+        await instance.shutdown();
+      }
+    });
+  });
+});