claw-dashboard 2.1.1 → 2.2.0

package/tests/rate-limiter.test.js

@@ -1,539 +0,0 @@
-/**
- * Unit tests for RateLimiter class
- */
-
-import alerts from '../src/alerts.js';
-
-const { RateLimiter } = alerts;
-
-describe('RateLimiter', () => {
-  beforeEach(() => {
-    alerts.resetRateLimit();
-  });
-
-  afterEach(() => {
-    alerts.resetRateLimit();
-  });
-
-  describe('constructor', () => {
-    test('should create RateLimiter with default options', () => {
-      const limiter = new RateLimiter();
-
-      expect(limiter.enabled).toBe(true);
-      expect(limiter.windowMs).toBe(60000);
-      expect(limiter.maxAlerts).toBe(5);
-      expect(limiter.alwaysAllowCritical).toBe(true);
-      expect(limiter.timestamps).toEqual({});
-    });
-
-    test('should create RateLimiter with custom options', () => {
-      const limiter = new RateLimiter({
-        enabled: false,
-        windowMs: 30000,
-        maxAlerts: 3,
-        alwaysAllowCritical: false
-      });
-
-      expect(limiter.enabled).toBe(false);
-      expect(limiter.windowMs).toBe(30000);
-      expect(limiter.maxAlerts).toBe(3);
-      expect(limiter.alwaysAllowCritical).toBe(false);
-    });
-
-    test('should partially apply custom options with defaults for others', () => {
-      const limiter = new RateLimiter({
-        maxAlerts: 10
-      });
-
-      expect(limiter.enabled).toBe(true);  // default
-      expect(limiter.windowMs).toBe(60000);  // default
-      expect(limiter.maxAlerts).toBe(10);  // custom
-      expect(limiter.alwaysAllowCritical).toBe(true);  // default
-    });
-  });
-
-  describe('check', () => {
-    test('should allow all alerts when disabled', () => {
-      const limiter = new RateLimiter({ enabled: false });
-
-      for (let i = 0; i < 10; i++) {
-        const result = limiter.check('cpu', 'warning');
-        expect(result.allowed).toBe(true);
-        expect(result.reason).toBe('rate_limiting_disabled');
-      }
-    });
-
-    test('should allow alert when under limit', () => {
-      const limiter = new RateLimiter({ maxAlerts: 3 });
-
-      const result = limiter.check('cpu', 'warning');
-      expect(result.allowed).toBe(true);
-      expect(result.reason).toBe('ok');
-    });
-
-    test('should block alert when over limit', () => {
-      const limiter = new RateLimiter({ maxAlerts: 2 });
-
-      // Record two alerts to reach limit
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-
-      const result = limiter.check('cpu', 'warning');
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toBe('rate_limit_exceeded');
-    });
-
-    test('should always allow critical when alwaysAllowCritical is true', () => {
-      const limiter = new RateLimiter({
-        maxAlerts: 1,
-        alwaysAllowCritical: true
-      });
-
-      // Record one alert to reach limit
-      limiter.record('cpu', 'warning');
-
-      // Warning should be blocked
-      const warningResult = limiter.check('cpu', 'warning');
-      expect(warningResult.allowed).toBe(false);
-
-      // Critical should be allowed
-      const criticalResult = limiter.check('cpu', 'critical');
-      expect(criticalResult.allowed).toBe(true);
-      expect(criticalResult.reason).toBe('critical_always_allowed');
-    });
-
-    test('should block critical when alwaysAllowCritical is false', () => {
-      const limiter = new RateLimiter({
-        maxAlerts: 1,
-        alwaysAllowCritical: false
-      });
-
-      // Record one alert to reach limit
-      limiter.record('cpu', 'critical');
-
-      // Another critical should be blocked
-      const result = limiter.check('cpu', 'critical');
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toBe('rate_limit_exceeded');
-    });
-
-    test('should track different alert types separately', () => {
-      const limiter = new RateLimiter({ maxAlerts: 1 });
-
-      // Fill up cpu
-      limiter.record('cpu', 'warning');
-      expect(limiter.check('cpu', 'warning').allowed).toBe(false);
-
-      // Memory should still be allowed
-      expect(limiter.check('memory', 'warning').allowed).toBe(true);
-    });
-
-    test('should default to warning level when not specified', () => {
-      const limiter = new RateLimiter({ maxAlerts: 1 });
-
-      limiter.record('cpu', 'warning');
-
-      // Check without level should use warning
-      const result = limiter.check('cpu');
-      expect(result.allowed).toBe(false);
-    });
-  });
-
-  describe('checkAndRecord', () => {
-    test('should check and record when allowed', () => {
-      const limiter = new RateLimiter({ maxAlerts: 2 });
-
-      const result = limiter.checkAndRecord('cpu', 'warning');
-      expect(result.allowed).toBe(true);
-      expect(result.reason).toBe('ok');
-
-      // Verify it was recorded
-      expect(limiter.getCount('cpu')).toBe(1);
-    });
-
-    test('should check but not record when blocked', () => {
-      const limiter = new RateLimiter({ maxAlerts: 1 });
-
-      // First alert
-      limiter.checkAndRecord('cpu', 'warning');
-      expect(limiter.getCount('cpu')).toBe(1);
-
-      // Second should be blocked and NOT recorded
-      const result = limiter.checkAndRecord('cpu', 'warning');
-      expect(result.allowed).toBe(false);
-      expect(result.reason).toBe('rate_limit_exceeded');
-      expect(limiter.getCount('cpu')).toBe(1);  // Still 1, not incremented
-    });
-
-    test('should allow critical even when rate limited and record it', () => {
-      const limiter = new RateLimiter({ maxAlerts: 1 });
-
-      // Fill up with warning
-      limiter.checkAndRecord('cpu', 'warning');
-
-      // Critical should pass and be recorded
-      const result = limiter.checkAndRecord('cpu', 'critical');
-      expect(result.allowed).toBe(true);
-      expect(result.reason).toBe('critical_always_allowed');
-      expect(limiter.getCount('cpu')).toBe(2);  // Both recorded
-    });
-
-    test('should not record when rate limiting disabled', () => {
-      const limiter = new RateLimiter({ enabled: false });
-
-      limiter.checkAndRecord('cpu', 'warning');
-      limiter.checkAndRecord('cpu', 'warning');
-
-      // Should not have recorded anything
-      expect(limiter.getCount('cpu')).toBe(0);
-    });
-  });
-
-  describe('record', () => {
-    test('should record alert timestamp', () => {
-      const limiter = new RateLimiter();
-
-      limiter.record('cpu', 'warning');
-      expect(limiter.getCount('cpu')).toBe(1);
-
-      limiter.record('cpu', 'warning');
-      expect(limiter.getCount('cpu')).toBe(2);
-    });
-
-    test('should not record when disabled', () => {
-      const limiter = new RateLimiter({ enabled: false });
-
-      limiter.record('cpu', 'warning');
-      expect(limiter.getCount('cpu')).toBe(0);
-    });
-
-    test('should record multiple types independently', () => {
-      const limiter = new RateLimiter();
-
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-      limiter.record('memory', 'warning');
-
-      expect(limiter.getCount('cpu')).toBe(2);
-      expect(limiter.getCount('memory')).toBe(1);
-      expect(limiter.getCount('disk')).toBe(0);
-    });
-  });
-
-  describe('getCount', () => {
-    test('should return 0 when no alerts recorded', () => {
-      const limiter = new RateLimiter();
-      expect(limiter.getCount('cpu')).toBe(0);
-    });
-
-    test('should return count of alerts in current window', () => {
-      const limiter = new RateLimiter({ windowMs: 60000 });
-
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-
-      expect(limiter.getCount('cpu')).toBe(3);
-    });
-
-    test('should exclude expired timestamps', async () => {
-      const limiter = new RateLimiter({ windowMs: 50 });
-
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-      expect(limiter.getCount('cpu')).toBe(2);
-
-      // Wait for window to expire
-      await new Promise(resolve => setTimeout(resolve, 60));
-
-      // Old timestamps should be expired
-      expect(limiter.getCount('cpu')).toBe(0);
-    });
-  });
-
-  describe('getRetryAfter', () => {
-    test('should return 0 when no alerts recorded', () => {
-      const limiter = new RateLimiter();
-      expect(limiter.getRetryAfter('cpu')).toBe(0);
-    });
-
-    test('should return 0 when under limit', () => {
-      const limiter = new RateLimiter({ maxAlerts: 3 });
-
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-
-      expect(limiter.getRetryAfter('cpu')).toBe(0);
-    });
-
-    test('should return time until oldest expires when at limit', async () => {
-      const windowMs = 100;
-      const limiter = new RateLimiter({ maxAlerts: 2, windowMs });
-
-      // Record two alerts at limit
-      limiter.record('cpu', 'warning');
-      await new Promise(resolve => setTimeout(resolve, 20));
-      limiter.record('cpu', 'warning');
-
-      // At limit, should return time until first expires
-      const retryAfter = limiter.getRetryAfter('cpu');
-      expect(retryAfter).toBeGreaterThan(0);
-      expect(retryAfter).toBeLessThanOrEqual(windowMs);
-    });
-
-    test('should return 0 after window expires', async () => {
-      const limiter = new RateLimiter({ maxAlerts: 1, windowMs: 50 });
-
-      limiter.record('cpu', 'warning');
-      expect(limiter.getRetryAfter('cpu')).toBeGreaterThan(0);
-
-      // Wait for window to expire
-      await new Promise(resolve => setTimeout(resolve, 60));
-
-      expect(limiter.getRetryAfter('cpu')).toBe(0);
-    });
-
-    test('should handle different types independently', () => {
-      const limiter = new RateLimiter({ maxAlerts: 1 });
-
-      limiter.record('cpu', 'warning');
-
-      expect(limiter.getRetryAfter('cpu')).toBeGreaterThan(0);
-      expect(limiter.getRetryAfter('memory')).toBe(0);
-    });
-  });
-
-  describe('getStatus', () => {
-    test('should return full status object', () => {
-      const limiter = new RateLimiter({
-        enabled: true,
-        windowMs: 30000,
-        maxAlerts: 3,
-        alwaysAllowCritical: false
-      });
-
-      const status = limiter.getStatus();
-
-      expect(status.enabled).toBe(true);
-      expect(status.windowMs).toBe(30000);
-      expect(status.maxAlerts).toBe(3);
-      expect(status.alwaysAllowCritical).toBe(false);
-      expect(status.types).toEqual({});
-    });
-
-    test('should include type status for recorded alerts', () => {
-      const limiter = new RateLimiter({ maxAlerts: 5 });
-
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-      limiter.record('memory', 'warning');
-
-      const status = limiter.getStatus();
-
-      expect(status.types.cpu).toEqual({
-        current: 2,
-        max: 5,
-        retryAfter: 0
-      });
-
-      expect(status.types.memory).toEqual({
-        current: 1,
-        max: 5,
-        retryAfter: 0
-      });
-
-      expect(status.types.disk).toBeUndefined();
-    });
-
-    test('should include retryAfter when at limit', () => {
-      const limiter = new RateLimiter({ maxAlerts: 2 });
-
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-
-      const status = limiter.getStatus();
-
-      expect(status.types.cpu.current).toBe(2);
-      expect(status.types.cpu.retryAfter).toBeGreaterThan(0);
-    });
-
-    test('should exclude expired timestamps from status', async () => {
-      const limiter = new RateLimiter({ maxAlerts: 2, windowMs: 50 });
-
-      limiter.record('cpu', 'warning');
-      limiter.record('cpu', 'warning');
-
-      await new Promise(resolve => setTimeout(resolve, 60));
-
-      const status = limiter.getStatus();
-      expect(status.types.cpu.current).toBe(0);
-      expect(status.types.cpu.retryAfter).toBe(0);
-    });
-  });
-
-  describe('configure', () => {
-    test('should update configuration', () => {
-      const limiter = new RateLimiter();
-
-      limiter.configure({
-        enabled: false,
-        windowMs: 30000,
-        maxAlerts: 10,
-        alwaysAllowCritical: false
-      });
-
-      expect(limiter.enabled).toBe(false);
-      expect(limiter.windowMs).toBe(30000);
-      expect(limiter.maxAlerts).toBe(10);
-      expect(limiter.alwaysAllowCritical).toBe(false);
-    });
-
-    test('should partially update configuration', () => {
-      const limiter = new RateLimiter();
-
-      limiter.configure({ maxAlerts: 20 });
-
-      expect(limiter.enabled).toBe(true);  // unchanged
-      expect(limiter.windowMs).toBe(60000);  // unchanged
-      expect(limiter.maxAlerts).toBe(20);  // updated
-    });
-
-    test('should affect subsequent checks', () => {
-      const limiter = new RateLimiter({ maxAlerts: 1 });
-
-      limiter.record('cpu', 'warning');
-      expect(limiter.check('cpu', 'warning').allowed).toBe(false);
-
-      // Increase limit
-      limiter.configure({ maxAlerts: 3 });
-
-      // Should now be allowed
-      expect(limiter.check('cpu', 'warning').allowed).toBe(true);
-    });
-  });
-
-  describe('reset', () => {
-    test('should clear all timestamps', () => {
-      const limiter = new RateLimiter();
-
-      limiter.record('cpu', 'warning');
-      limiter.record('memory', 'warning');
-
-      expect(limiter.getCount('cpu')).toBe(1);
-      expect(limiter.getCount('memory')).toBe(1);
-
-      limiter.reset();
-
-      expect(limiter.getCount('cpu')).toBe(0);
-      expect(limiter.getCount('memory')).toBe(0);
-      expect(limiter.timestamps).toEqual({});
-    });
-
-    test('should allow alerts after reset', () => {
-      const limiter = new RateLimiter({ maxAlerts: 1 });
-
-      limiter.record('cpu', 'warning');
-      expect(limiter.check('cpu', 'warning').allowed).toBe(false);
-
-      limiter.reset();
-
-      expect(limiter.check('cpu', 'warning').allowed).toBe(true);
-    });
-
-    test('should preserve configuration after reset', () => {
-      const limiter = new RateLimiter({ maxAlerts: 10, windowMs: 30000 });
-
-      limiter.reset();
-
-      expect(limiter.maxAlerts).toBe(10);
-      expect(limiter.windowMs).toBe(30000);
-    });
-  });
-
-  describe('alwaysAllowCritical behavior', () => {
-    test('should allow critical alerts past limit when true', () => {
-      const limiter = new RateLimiter({
-        maxAlerts: 1,
-        alwaysAllowCritical: true
-      });
-
-      limiter.record('cpu', 'warning');
-
-      expect(limiter.check('cpu', 'critical').allowed).toBe(true);
-      expect(limiter.check('cpu', 'warning').allowed).toBe(false);
-    });
-
-    test('should block critical alerts past limit when false', () => {
-      const limiter = new RateLimiter({
-        maxAlerts: 1,
-        alwaysAllowCritical: false
-      });
-
-      limiter.record('cpu', 'critical');
-
-      expect(limiter.check('cpu', 'critical').allowed).toBe(false);
-    });
-
-    test('should respect level parameter variations', () => {
-      const limiter = new RateLimiter({
-        maxAlerts: 1,
-        alwaysAllowCritical: true
-      });
-
-      limiter.record('cpu', 'warning');
-
-      // Various non-critical levels should be blocked
-      expect(limiter.check('cpu', 'warning').allowed).toBe(false);
-      expect(limiter.check('cpu', 'info').allowed).toBe(false);
-
-      // Critical should pass
-      expect(limiter.check('cpu', 'critical').allowed).toBe(true);
-    });
-
-    test('should be configurable at runtime', () => {
-      const limiter = new RateLimiter({
-        maxAlerts: 1,
-        alwaysAllowCritical: true
-      });
-
-      limiter.record('cpu', 'warning');
-
-      // Initially allowed
-      expect(limiter.check('cpu', 'critical').allowed).toBe(true);
-
-      // Disable critical bypass
-      limiter.configure({ alwaysAllowCritical: false });
-
-      // Fill up again
-      limiter.record('cpu', 'critical');
-
-      // Should now be blocked
-      expect(limiter.check('cpu', 'critical').allowed).toBe(false);
-    });
-  });
-
-  describe('integration with global rate limiting', () => {
-    test('should sync with global config on creation', () => {
-      // Create limiter should sync its config to global
-      new RateLimiter({ maxAlerts: 7 });
-
-      const globalConfig = alerts.getRateLimit();
-      expect(globalConfig.maxAlerts).toBe(7);
-    });
-
-    test('should sync with global config on configure', () => {
-      const limiter = new RateLimiter();
-
-      limiter.configure({ maxAlerts: 15 });
-
-      const globalConfig = alerts.getRateLimit();
-      expect(globalConfig.maxAlerts).toBe(15);
-    });
-
-    test('defaultRateLimiter instance should exist', () => {
-      // Verify the exported defaultRateLimiter exists
-      expect(alerts.defaultRateLimiter).toBeDefined();
-      expect(alerts.defaultRateLimiter).toBeInstanceOf(RateLimiter);
-    });
-  });
-});

package/tests/removed-dependencies.test.js

@@ -1,74 +0,0 @@
-/**
- * Tests for removed dependencies and widgets
- * Verifies cleanup after blessed-contrib and NetworkWidget removal
- */
-
-import { jest } from '@jest/globals';
-import { describe, test, expect } from '@jest/globals';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-describe('Removed dependencies cleanup', () => {
-  describe('blessed-contrib removal', () => {
-    test('should not have blessed-contrib in package.json dependencies', () => {
-      const pkg = JSON.parse(
-        readFileSync(join(__dirname, '../package.json'), 'utf8')
-      );
-      expect(pkg.dependencies).not.toHaveProperty('blessed-contrib');
-    });
-
-    test('should not import blessed-contrib in index.js', () => {
-      const indexContent = readFileSync(join(__dirname, '../index.js'), 'utf8');
-      expect(indexContent).not.toContain("import contrib from 'blessed-contrib'");
-      expect(indexContent).not.toContain('blessed-contrib');
-    });
-  });
-
-  describe('NetworkWidget removal', () => {
-    test('should not export NetworkWidget from widgets/index.js', async () => {
-      const widgets = await import('../src/widgets/index.js');
-      expect(widgets.NetworkWidget).toBeUndefined();
-    });
-
-    test('should not have NetworkWidget in builtin-widgets exports', async () => {
-      const builtin = await import('../src/widgets/builtin-widgets.js');
-      expect(builtin.NetworkWidget).toBeUndefined();
-      expect(builtin.WIDGET_REGISTRY).not.toHaveProperty('network');
-    });
-
-    test('builtin-widgets should not reference blessed-contrib', () => {
-      const content = readFileSync(
-        join(__dirname, '../src/widgets/builtin-widgets.js'),
-        'utf8'
-      );
-      expect(content).not.toContain('blessed-contrib');
-      expect(content).not.toContain('contrib.sparkline');
-    });
-  });
-
-  describe('@pm2/blessed migration', () => {
-    test('should have @pm2/blessed as dependency', () => {
-      const pkg = JSON.parse(
-        readFileSync(join(__dirname, '../package.json'), 'utf8')
-      );
-      expect(pkg.dependencies).toHaveProperty('@pm2/blessed');
-    });
-
-    test('should have blessed aliased to @pm2/blessed', () => {
-      const pkg = JSON.parse(
-        readFileSync(join(__dirname, '../package.json'), 'utf8')
-      );
-      expect(pkg.dependencies.blessed).toBe('npm:@pm2/blessed@^0.1.81');
-    });
-
-    test('should be able to import blessed', async () => {
-      // This verifies the alias is working
-      const blessed = await import('blessed');
-      expect(typeof blessed.default).toBe('function');
-    });
-  });
-});