claw-dashboard 1.9.0 → 2.0.0

package/tests/performance-monitor.test.js

@@ -0,0 +1,190 @@
+/**
+ * Tests for Performance Monitor module
+ */
+
+import { jest } from '@jest/globals';
+import { PerformanceMonitor } from '../src/performance-monitor.js';
+
+describe('PerformanceMonitor', () => {
+  let monitor;
+
+  beforeEach(() => {
+    monitor = new PerformanceMonitor();
+  });
+
+  afterEach(() => {
+    monitor.stop();
+  });
+
+  describe('start/stop', () => {
+    test('starts monitoring when start() is called', () => {
+      expect(monitor.isTracking).toBe(false);
+      monitor.start();
+      expect(monitor.isTracking).toBe(true);
+    });
+
+    test('stops monitoring when stop() is called', () => {
+      monitor.start();
+      expect(monitor.isTracking).toBe(true);
+      monitor.stop();
+      expect(monitor.isTracking).toBe(false);
+    });
+  });
+
+  describe('record', () => {
+    test('returns null when not tracking', async () => {
+      const result = await monitor.record();
+      expect(result).toBeNull();
+    });
+
+    test('records metrics when tracking', async () => {
+      monitor.start();
+      const result = await monitor.record(2000);
+
+      expect(result).toBeDefined();
+      expect(result.timestamp).toBeGreaterThan(0);
+      expect(result.refreshRate).toBe(2000);
+      expect(typeof result.memoryUsed).toBe('number');
+      expect(typeof result.memoryPercent).toBe('number');
+      expect(typeof result.cpuPercent).toBe('number');
+      expect(typeof result.uptime).toBe('number');
+    });
+
+    test('maintains history within max limit', () => {
+      monitor.start();
+      monitor.maxHistory = 5;
+
+      for (let i = 0; i < 10; i++) {
+        monitor.record(2000);
+      }
+
+      expect(monitor.history.length).toBeLessThanOrEqual(5);
+    });
+  });
+
+  describe('getMetrics', () => {
+    test('returns current metrics', () => {
+      monitor.start();
+      monitor.record(2000);
+
+      const metrics = monitor.getMetrics();
+      expect(metrics.current).toBeDefined();
+      expect(metrics.history).toBeDefined();
+      expect(metrics.aggregates).toBeDefined();
+      expect(metrics.isTracking).toBe(true);
+    });
+
+    test('returns empty aggregates when no history', () => {
+      const metrics = monitor.getMetrics();
+      expect(metrics.aggregates.avgMemoryUsed).toBe(0);
+      expect(metrics.aggregates.peakMemoryUsed).toBe(0);
+    });
+  });
+
+  describe('getStatusString', () => {
+    test('returns inactive message when no history', () => {
+      const status = monitor.getStatusString();
+      expect(status).toBe('Performance monitoring inactive');
+    });
+
+    test('returns formatted status when tracking', async () => {
+      monitor.start();
+      await monitor.record(2000);
+
+      const status = monitor.getStatusString();
+      expect(status).toContain('MEM:');
+      expect(status).toContain('MB');
+      expect(status).toContain('CPU:');
+      expect(status).toContain('Refresh:');
+    });
+
+    test('includes detailed metrics when requested', async () => {
+      monitor.start();
+      await monitor.record(2000);
+
+      const status = monitor.getStatusString(true);
+      expect(status).toContain('MEM:');
+    });
+  });
+
+  describe('getMemorySparkline', () => {
+    test('returns data array', () => {
+      monitor.start();
+      monitor.record(2000);
+      monitor.record(2000);
+
+      const data = monitor.getMemorySparkline();
+      expect(Array.isArray(data)).toBe(true);
+      expect(data.length).toBeGreaterThan(0);
+    });
+
+    test('returns array with zero when no history', () => {
+      const data = monitor.getMemorySparkline();
+      expect(data).toEqual([0]);
+    });
+  });
+
+  describe('getCpuSparkline', () => {
+    test('returns data array', () => {
+      monitor.start();
+      monitor.record(2000);
+
+      const data = monitor.getCpuSparkline();
+      expect(Array.isArray(data)).toBe(true);
+    });
+  });
+
+  describe('checkHealth', () => {
+    test('returns not degraded for normal metrics', async () => {
+      monitor.start();
+      await monitor.record(2000);
+
+      const health = monitor.checkHealth();
+      expect(health.degraded).toBe(false);
+      expect(health.reasons).toEqual([]);
+    });
+
+    test('returns degraded for high memory usage', () => {
+      monitor.start();
+      // Mock high memory usage
+      monitor.history.push({
+        timestamp: Date.now(),
+        memoryPercent: 90,
+        cpuPercent: 10,
+      });
+
+      const health = monitor.checkHealth();
+      expect(health.degraded).toBe(true);
+      expect(health.reasons.length).toBeGreaterThan(0);
+      expect(health.reasons[0]).toContain('memory');
+    });
+
+    test('returns degraded for high CPU usage', () => {
+      monitor.start();
+      monitor.history.push({
+        timestamp: Date.now(),
+        memoryPercent: 50,
+        cpuPercent: 85,
+      });
+
+      const health = monitor.checkHealth();
+      expect(health.degraded).toBe(true);
+      expect(health.reasons.some(r => r.includes('CPU'))).toBe(true);
+    });
+  });
+
+  describe('reset', () => {
+    test('clears history and resets metrics', async () => {
+      monitor.start();
+      await monitor.record(2000);
+      await monitor.record(2000);
+
+      expect(monitor.history.length).toBeGreaterThan(0);
+
+      monitor.reset();
+
+      expect(monitor.history.length).toBe(0);
+      expect(monitor.metrics.avgMemoryUsed).toBe(0);
+    });
+  });
+});

package/tests/plugin-api-rate-limit.test.js

@@ -0,0 +1,302 @@
+/**
+ * Tests for Plugin API rate limiting
+ */
+
+import { jest } from '@jest/globals';
+import { PluginAPI, BaseWidget } from '../src/widgets/plugin-api.js';
+
+describe('PluginAPI Rate Limiting', () => {
+  let api;
+
+  beforeEach(() => {
+    api = new PluginAPI({
+      rateLimit: {
+        enabled: true,
+        windowMs: 60000,
+        maxCalls: 5,
+        alwaysAllowCritical: false
+      }
+    });
+  });
+
+  afterEach(() => {
+    api.rateLimiter.reset();
+  });
+
+  describe('Constructor', () => {
+    test('should create API with default rate limit config', () => {
+      const defaultApi = new PluginAPI();
+      const status = defaultApi.getRateLimitStatus();
+
+      expect(status.enabled).toBe(true);
+      expect(status.windowMs).toBe(60000);
+      expect(status.maxAlerts).toBe(100);
+    });
+
+    test('should create API with custom rate limit config', () => {
+      const customApi = new PluginAPI({
+        rateLimit: {
+          enabled: true,
+          windowMs: 30000,
+          maxCalls: 10,
+          alwaysAllowCritical: true
+        }
+      });
+      const status = customApi.getRateLimitStatus();
+
+      expect(status.enabled).toBe(true);
+      expect(status.windowMs).toBe(30000);
+      expect(status.maxAlerts).toBe(10);
+      expect(status.alwaysAllowCritical).toBe(true);
+    });
+
+    test('should allow disabling rate limiting', () => {
+      const unlimitedApi = new PluginAPI({
+        rateLimit: { enabled: false }
+      });
+      const status = unlimitedApi.getRateLimitStatus();
+
+      expect(status.enabled).toBe(false);
+    });
+  });
+
+  describe('getData rate limiting', () => {
+    test('should allow calls under limit', async () => {
+      api.registerDataProvider('test', async () => ({ data: 'test' }));
+
+      const result = await api.getData('test');
+      expect(result).toEqual({ data: 'test' });
+    });
+
+    test('should block calls over limit', async () => {
+      api.registerDataProvider('test', async () => ({ data: 'test' }));
+
+      // Make maxCalls calls
+      for (let i = 0; i < 5; i++) {
+        await api.getData('test');
+      }
+
+      // Next call should be rate limited
+      await expect(api.getData('test')).rejects.toThrow('Rate limit exceeded');
+    });
+
+    test('should include retryAfter in rate limit error', async () => {
+      api.registerDataProvider('test', async () => ({ data: 'test' }));
+
+      // Exhaust limit
+      for (let i = 0; i < 5; i++) {
+        await api.getData('test');
+      }
+
+      try {
+        await api.getData('test');
+        fail('Should have thrown');
+      } catch (err) {
+        expect(err.code).toBe('RATE_LIMIT_EXCEEDED');
+        expect(err.retryAfter).toBeDefined();
+        expect(err.retryAfter).toBeGreaterThan(0);
+      }
+    });
+
+    test('should not rate limit when disabled', async () => {
+      const unlimitedApi = new PluginAPI({
+        rateLimit: { enabled: false, maxCalls: 1 }
+      });
+      unlimitedApi.registerDataProvider('test', async () => ({ data: 'test' }));
+
+      // Should allow unlimited calls
+      for (let i = 0; i < 10; i++) {
+        const result = await unlimitedApi.getData('test');
+        expect(result).toEqual({ data: 'test' });
+      }
+    });
+
+    test('should track getData category separately', async () => {
+      api.registerDataProvider('test', async () => ({ data: 'test' }));
+
+      // Make calls
+      await api.getData('test');
+
+      const status = api.getRateLimitStatus();
+      expect(status.types.getData).toBeDefined();
+      expect(status.types.getData.current).toBe(1);
+    });
+  });
+
+  describe('executeExtension rate limiting', () => {
+    test('should allow extension calls under limit', async () => {
+      api.registerExtensionPoint('test-extension', { multiple: true });
+      api.extend('test-extension', async () => 'result');
+
+      const results = await api.executeExtension('test-extension');
+      expect(results).toHaveLength(1);
+      expect(results[0].result).toBe('result');
+    });
+
+    test('should block extension calls over limit', async () => {
+      api.registerExtensionPoint('test-extension', { multiple: true });
+      api.extend('test-extension', async () => 'result');
+
+      // Make maxCalls calls
+      for (let i = 0; i < 5; i++) {
+        await api.executeExtension('test-extension');
+      }
+
+      // Next call should be rate limited
+      await expect(api.executeExtension('test-extension')).rejects.toThrow('Rate limit exceeded');
+    });
+
+    test('should track executeExtension category separately', async () => {
+      api.registerExtensionPoint('test-extension', { multiple: true });
+      api.extend('test-extension', async () => 'result');
+
+      await api.executeExtension('test-extension');
+
+      const status = api.getRateLimitStatus();
+      expect(status.types.executeExtension).toBeDefined();
+      expect(status.types.executeExtension.current).toBe(1);
+    });
+  });
+
+  describe('getMetrics rate limiting', () => {
+    test('should allow metrics calls under limit', async () => {
+      const dataProvider = jest.fn().mockResolvedValue({ cpu: 50 });
+      const metricsApi = new PluginAPI({
+        dataProvider,
+        rateLimit: { enabled: true, maxCalls: 5 }
+      });
+
+      const result = await metricsApi.getMetrics('cpu');
+      expect(result).toEqual({ cpu: 50 });
+    });
+
+    test('should block metrics calls over limit', async () => {
+      const dataProvider = jest.fn().mockResolvedValue({ cpu: 50 });
+      const metricsApi = new PluginAPI({
+        dataProvider,
+        rateLimit: { enabled: true, maxCalls: 5 }
+      });
+
+      // Make maxCalls calls
+      for (let i = 0; i < 5; i++) {
+        await metricsApi.getMetrics('cpu');
+      }
+
+      // Next call should be rate limited
+      await expect(metricsApi.getMetrics('cpu')).rejects.toThrow('Rate limit exceeded');
+    });
+
+    test('should track getMetrics category separately', async () => {
+      const dataProvider = jest.fn().mockResolvedValue({ cpu: 50 });
+      const metricsApi = new PluginAPI({
+        dataProvider,
+        rateLimit: { enabled: true, maxCalls: 5 }
+      });
+
+      await metricsApi.getMetrics('cpu');
+
+      const status = metricsApi.getRateLimitStatus();
+      expect(status.types.getMetrics).toBeDefined();
+      expect(status.types.getMetrics.current).toBe(1);
+    });
+  });
+
+  describe('Rate limit configuration', () => {
+    test('should allow runtime configuration', () => {
+      api.configureRateLimit({ maxCalls: 20 });
+
+      const status = api.getRateLimitStatus();
+      expect(status.maxAlerts).toBe(20);
+    });
+
+    test('should allow disabling at runtime', () => {
+      api.configureRateLimit({ enabled: false });
+
+      const status = api.getRateLimitStatus();
+      expect(status.enabled).toBe(false);
+    });
+
+    test('should get rate limiter instance for custom use', () => {
+      const limiter = api.getRateLimiter();
+
+      expect(limiter).toBeDefined();
+      expect(typeof limiter.check).toBe('function');
+      expect(typeof limiter.checkAndRecord).toBe('function');
+    });
+  });
+
+  describe('Independent category tracking', () => {
+    test('should track getData and executeExtension independently', async () => {
+      api.registerDataProvider('test', async () => ({ data: 'test' }));
+      api.registerExtensionPoint('test-ext', { multiple: true });
+      api.extend('test-ext', async () => 'result');
+
+      // Fill up getData limit
+      for (let i = 0; i < 5; i++) {
+        await api.getData('test');
+      }
+
+      // executeExtension should still be allowed
+      const results = await api.executeExtension('test-ext');
+      expect(results).toHaveLength(1);
+
+      const status = api.getRateLimitStatus();
+      expect(status.types.getData.current).toBe(5);
+      expect(status.types.executeExtension.current).toBe(1);
+    });
+
+    test('should track getMetrics independently from getData', async () => {
+      const dataProvider = jest.fn().mockResolvedValue({ cpu: 50 });
+      const metricsApi = new PluginAPI({
+        dataProvider,
+        rateLimit: { enabled: true, maxCalls: 5 }
+      });
+      metricsApi.registerDataProvider('test', async () => ({ data: 'test' }));
+
+      // Fill up getMetrics limit
+      for (let i = 0; i < 5; i++) {
+        await metricsApi.getMetrics('cpu');
+      }
+
+      // getData should still be allowed
+      await metricsApi.getData('test');
+
+      const status = metricsApi.getRateLimitStatus();
+      expect(status.types.getMetrics.current).toBe(5);
+      expect(status.types.getData.current).toBe(1);
+    });
+  });
+
+  describe('Integration with BaseWidget', () => {
+    test('should provide rate limiter to widgets via API', async () => {
+      class TestWidget extends BaseWidget {
+        constructor(options) {
+          super(options);
+        }
+      }
+
+      const widget = new TestWidget({ api });
+      const limiter = widget.api.getRateLimiter();
+
+      expect(limiter).toBeDefined();
+    });
+
+    test('widgets can configure rate limits', async () => {
+      class TestWidget extends BaseWidget {
+        constructor(options) {
+          super(options);
+        }
+
+        configureApiRateLimit() {
+          this.api.configureRateLimit({ maxCalls: 50 });
+        }
+      }
+
+      const widget = new TestWidget({ api });
+      widget.configureApiRateLimit();
+
+      const status = widget.api.getRateLimitStatus();
+      expect(status.maxAlerts).toBe(50);
+    });
+  });
+});