@onlineapps/conn-base-monitoring 1.0.0

package/test/unit/monitoring.test.js

@@ -0,0 +1,376 @@
+/**
+ * Unit tests for conn-base-monitoring
+ */
+
+// Mock monitoring-core to avoid RabbitMQ connections in tests
+jest.mock('@onlineapps/monitoring-core', () => ({
+  init: jest.fn(async (config) => ({
+    config: {
+      ...config,
+      mode: config.mode || 'off'  // Default to 'off' mode
+    },
+    logger: {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+      log: jest.fn()
+    },
+    workflow: {
+      start: jest.fn((id) => id),
+      step: jest.fn(),
+      end: jest.fn(),
+      error: jest.fn(),
+      activeWorkflows: new Map(),
+      getWorkflow: jest.fn()
+    },
+    createCounter: jest.fn(() => ({ add: jest.fn() })),
+    createHistogram: jest.fn(() => ({ record: jest.fn() })),
+    createMetric: jest.fn(() => ({ add: jest.fn(), record: jest.fn() })),
+    shutdown: jest.fn(() => Promise.resolve())
+  })),
+  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, getInstance, createLogger, WorkflowTracker } = require('../../src');
+
+describe('conn-base-monitoring Unit Tests', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Module Exports', () => {
+    test('should export init function', () => {
+      expect(init).toBeDefined();
+      expect(typeof init).toBe('function');
+    });
+
+    test('should export getInstance function', () => {
+      expect(getInstance).toBeDefined();
+      expect(typeof getInstance).toBe('function');
+    });
+
+    test('should export createLogger function', () => {
+      expect(createLogger).toBeDefined();
+      expect(typeof createLogger).toBe('function');
+    });
+
+    test('should export WorkflowTracker class', () => {
+      expect(WorkflowTracker).toBeDefined();
+      expect(typeof WorkflowTracker).toBe('function');
+    });
+  });
+
+  describe('Initialization', () => {
+    test('should initialize monitoring with config', async () => {
+      const monitoring = await init({
+        serviceName: 'test-service',
+        mode: 'off'
+      });
+
+      expect(monitoring).toBeDefined();
+      expect(monitoring.logger).toBeDefined();
+      expect(monitoring.workflow).toBeDefined();
+    });
+
+    test('should provide logger methods', async () => {
+      const monitoring = await init({
+        serviceName: 'logger-test',
+        mode: 'off'
+      });
+
+      expect(monitoring.info).toBeDefined();
+      expect(monitoring.error).toBeDefined();
+      expect(monitoring.warn).toBeDefined();
+      expect(monitoring.debug).toBeDefined();
+      expect(monitoring.log).toBeDefined();
+    });
+
+    test('should provide workflow methods', async () => {
+      const monitoring = await init({
+        serviceName: 'workflow-test',
+        mode: 'off'
+      });
+
+      expect(monitoring.startWorkflow).toBeDefined();
+      expect(monitoring.stepWorkflow).toBeDefined();
+      expect(monitoring.endWorkflow).toBeDefined();
+      expect(monitoring.errorWorkflow).toBeDefined();
+    });
+
+    test('should provide metric methods', async () => {
+      const monitoring = await init({
+        serviceName: 'metrics-test',
+        mode: 'off'
+      });
+
+      expect(monitoring.createCounter).toBeDefined();
+      expect(monitoring.createHistogram).toBeDefined();
+      expect(monitoring.createMetric).toBeDefined();
+    });
+  });
+
+  describe('Logger Operations', () => {
+    let monitoring;
+
+    beforeEach(async () => {
+      monitoring = await init({
+        serviceName: 'logger-ops',
+        mode: 'off',
+        logLevel: 'DEBUG'
+      });
+    });
+
+    test('should log info messages', () => {
+      expect(() => {
+        monitoring.info('Info message', { data: 'test' });
+      }).not.toThrow();
+    });
+
+    test('should log error messages', () => {
+      expect(() => {
+        monitoring.error('Error message', { error: 'details' });
+      }).not.toThrow();
+    });
+
+    test('should log warning messages', () => {
+      expect(() => {
+        monitoring.warn('Warning message');
+      }).not.toThrow();
+    });
+
+    test('should log debug messages', () => {
+      expect(() => {
+        monitoring.debug('Debug message', { verbose: true });
+      }).not.toThrow();
+    });
+
+    test('should handle log without data', () => {
+      expect(() => {
+        monitoring.info('Simple message');
+        monitoring.error('Error without data');
+      }).not.toThrow();
+    });
+  });
+
+  describe('Workflow Operations', () => {
+    let monitoring;
+
+    beforeEach(async () => {
+      monitoring = await init({
+        serviceName: 'workflow-ops',
+        mode: 'off'
+      });
+    });
+
+    test('should start workflow', () => {
+      const workflowId = monitoring.startWorkflow('wf-1', 'process', {
+        userId: '123'
+      });
+
+      expect(workflowId).toBe('wf-1');
+    });
+
+    test('should add workflow step', () => {
+      monitoring.startWorkflow('wf-2', 'pipeline');
+
+      expect(() => {
+        monitoring.stepWorkflow('wf-2', 'validation', { status: 'ok' });
+      }).not.toThrow();
+    });
+
+    test('should end workflow', () => {
+      monitoring.startWorkflow('wf-3', 'batch');
+
+      expect(() => {
+        monitoring.endWorkflow('wf-3', 'success', { records: 100 });
+      }).not.toThrow();
+    });
+
+    test('should handle workflow error', () => {
+      monitoring.startWorkflow('wf-error', 'risky');
+
+      expect(() => {
+        monitoring.errorWorkflow('wf-error', new Error('Test error'), {
+          code: 500
+        });
+      }).not.toThrow();
+    });
+
+    test('should handle non-existent workflow gracefully', () => {
+      expect(() => {
+        monitoring.stepWorkflow('non-existent', 'step');
+        monitoring.endWorkflow('non-existent', 'failed');
+      }).not.toThrow();
+    });
+  });
+
+  describe('Metrics Operations', () => {
+    let monitoring;
+
+    beforeEach(async () => {
+      monitoring = await init({
+        serviceName: 'metrics-ops',
+        mode: 'off'
+      });
+    });
+
+    test('should create counter metric', () => {
+      const counter = monitoring.createCounter('requests', {
+        description: 'Request counter'
+      });
+
+      expect(counter).toBeDefined();
+      expect(counter.add).toBeDefined();
+    });
+
+    test('should create histogram metric', () => {
+      const histogram = monitoring.createHistogram('latency', {
+        description: 'Response latency',
+        unit: 'ms'
+      });
+
+      expect(histogram).toBeDefined();
+      expect(histogram.record).toBeDefined();
+    });
+
+    test('should create metric with type', () => {
+      const metric = monitoring.createMetric('custom', 'counter', {
+        description: 'Custom counter'
+      });
+
+      expect(metric).toBeDefined();
+      expect(metric.add).toBeDefined();
+      expect(metric.record).toBeDefined();
+    });
+
+    test('should use counter metric', () => {
+      const counter = monitoring.createCounter('api.calls');
+
+      expect(() => {
+        counter.add(1, { endpoint: '/api/users' });
+      }).not.toThrow();
+    });
+
+    test('should use histogram metric', () => {
+      const histogram = monitoring.createHistogram('response.time');
+
+      expect(() => {
+        histogram.record(235.5, { endpoint: '/api/users' });
+      }).not.toThrow();
+    });
+  });
+
+  describe('Configuration', () => {
+    test('should use default configuration', async () => {
+      const monitoring = await init({
+        serviceName: 'default-config'
+      });
+
+      expect(monitoring.config).toBeDefined();
+      expect(monitoring.config.serviceName).toBe('default-config');
+      // Default mode is 'light' when not specified
+      expect(monitoring.config.mode).toBe('light');
+    });
+
+    test('should override with environment variables', async () => {
+      process.env.MONITORING_MODE = 'debug';
+
+      const monitoring = await init({
+        serviceName: 'env-config'
+      });
+
+      expect(monitoring.config.mode).toBe('debug');
+
+      delete process.env.MONITORING_MODE;
+    });
+
+    test('should handle all monitoring modes', async () => {
+      const modes = ['off', 'light', 'full', 'debug'];
+
+      for (const mode of modes) {
+        const monitoring = await init({
+          serviceName: `mode-${mode}`,
+          mode
+        });
+
+        expect(monitoring.config.mode).toBe(mode);
+      }
+    });
+  });
+
+  describe('Singleton Pattern', () => {
+    test('should return singleton instance', () => {
+      const instance1 = getInstance();
+      const instance2 = getInstance();
+
+      expect(instance1).toBe(instance2);
+    });
+
+    test('should create singleton on first getInstance', () => {
+      // Clear any existing singleton
+      const module = require('../../src');
+      if (module._singletonInstance) {
+        delete module._singletonInstance;
+      }
+
+      const instance = getInstance();
+      expect(instance).toBeDefined();
+    });
+  });
+
+  describe('Direct Module Usage', () => {
+    test('should create logger directly', () => {
+      const logger = createLogger({
+        serviceName: 'direct-logger',
+        mode: 'off'
+      });
+
+      expect(logger).toBeDefined();
+      expect(logger.info).toBeDefined();
+      expect(logger.error).toBeDefined();
+    });
+
+    test('should create workflow tracker directly', () => {
+      const tracker = new WorkflowTracker('direct-tracker');
+
+      expect(tracker).toBeDefined();
+      expect(tracker.serviceName).toBe('direct-tracker');
+      expect(tracker.start).toBeDefined();
+    });
+  });
+
+  describe('Shutdown', () => {
+    test('should handle shutdown gracefully', async () => {
+      const monitoring = await init({
+        serviceName: 'shutdown-test',
+        mode: 'off'
+      });
+
+      await monitoring.shutdown();
+      expect(monitoring.core.shutdown).toHaveBeenCalled();
+    });
+
+    test('should handle multiple shutdowns', async () => {
+      const monitoring = await init({
+        serviceName: 'multi-shutdown',
+        mode: 'off'
+      });
+
+      await monitoring.shutdown();
+      await monitoring.shutdown();  // Should handle multiple calls gracefully
+      expect(monitoring.core.shutdown).toHaveBeenCalledTimes(2);
+    });
+  });
+});