claw-dashboard 2.1.1 → 2.2.0

package/tests/example-plugins.test.js

@@ -1,624 +0,0 @@
-/**
- * Example Plugin Tests
- * Tests for loading, lifecycle hooks, and manifest validation of example plugins
- */
-
-import { jest } from '@jest/globals';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { mkdtemp, rm, writeFile, readFile, mkdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import { tmpdir } from 'os';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Import modules under test
-import { WidgetLoader } from '../src/widgets/widget-loader.js';
-import { validateManifest, BaseWidget, PluginAPI } from '../src/widgets/plugin-api.js';
-
-describe('Example Plugin Loading', () => {
-  let loader;
-  let tempDir;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'example-plugin-test-'));
-    loader = new WidgetLoader({ pluginsDir: tempDir });
-  });
-
-  afterEach(async () => {
-    if (loader) {
-      await loader.clear();
-    }
-    if (tempDir) {
-      await rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('Plugin Manifest Validation', () => {
-    test('should validate hello-world plugin manifest has required fields', async () => {
-      const manifestPath = join(__dirname, '..', 'examples', 'plugins', 'hello-world', 'plugin.json');
-      const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
-
-      // The validateManifest expects 'entryPoint' but example plugins use 'id'
-      // Test that the manifest has the expected fields for the example plugin format
-      expect(manifest.id).toBe('example-hello-world');
-      expect(manifest.name).toBe('Hello World');
-      expect(manifest.version).toBe('1.0.0');
-      expect(manifest.type).toBe('widget');
-
-      // Validate using the expected format (entryPoint required)
-      const compatibleManifest = {
-        name: manifest.name,
-        version: manifest.version,
-        entryPoint: 'index.js',
-      };
-      expect(() => validateManifest(compatibleManifest)).not.toThrow();
-    });
-
-    test('should validate api-status plugin manifest has required fields', async () => {
-      const manifestPath = join(__dirname, '..', 'examples', 'plugins', 'api-status', 'plugin.json');
-      const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
-
-      expect(manifest.id).toBe('example-api-status');
-      expect(manifest.name).toBe('API Status');
-      expect(manifest.version).toBe('1.1.0');
-      expect(manifest.type).toBe('widget');
-
-      const compatibleManifest = {
-        name: manifest.name,
-        version: manifest.version,
-        entryPoint: 'index.js',
-      };
-      expect(() => validateManifest(compatibleManifest)).not.toThrow();
-    });
-
-    test('should validate system-metrics-chart plugin manifest has required fields', async () => {
-      const manifestPath = join(__dirname, '..', 'examples', 'plugins', 'system-metrics-chart', 'plugin.json');
-      const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
-
-      expect(manifest.id).toBe('example-system-metrics-chart');
-      expect(manifest.name).toBe('System Metrics Chart');
-      expect(manifest.version).toBe('1.0.0');
-      expect(manifest.type).toBe('widget');
-
-      const compatibleManifest = {
-        name: manifest.name,
-        version: manifest.version,
-        entryPoint: 'index.js',
-      };
-      expect(() => validateManifest(compatibleManifest)).not.toThrow();
-    });
-
-    test('should validate weather-widget plugin manifest has required fields', async () => {
-      const manifestPath = join(__dirname, '..', 'examples', 'plugins', 'weather-widget', 'plugin.json');
-      const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
-
-      expect(manifest.id).toBe('example-weather');
-      expect(manifest.name).toBe('Weather');
-      expect(manifest.version).toBe('1.0.0');
-      expect(manifest.type).toBe('widget');
-
-      const compatibleManifest = {
-        name: manifest.name,
-        version: manifest.version,
-        entryPoint: 'index.js',
-      };
-      expect(() => validateManifest(compatibleManifest)).not.toThrow();
-    });
-  });
-
-  describe('Plugin Directory Structure', () => {
-    test('hello-world has required files', () => {
-      const pluginDir = join(__dirname, '..', 'examples', 'plugins', 'hello-world');
-
-      expect(existsSync(join(pluginDir, 'plugin.json'))).toBe(true);
-      expect(existsSync(join(pluginDir, 'index.js'))).toBe(true);
-    });
-
-    test('api-status has required files', () => {
-      const pluginDir = join(__dirname, '..', 'examples', 'plugins', 'api-status');
-
-      expect(existsSync(join(pluginDir, 'plugin.json'))).toBe(true);
-      expect(existsSync(join(pluginDir, 'index.js'))).toBe(true);
-    });
-
-    test('system-metrics-chart has required files', () => {
-      const pluginDir = join(__dirname, '..', 'examples', 'plugins', 'system-metrics-chart');
-
-      expect(existsSync(join(pluginDir, 'plugin.json'))).toBe(true);
-      expect(existsSync(join(pluginDir, 'index.js'))).toBe(true);
-    });
-
-    test('weather-widget has required files', () => {
-      const pluginDir = join(__dirname, '..', 'examples', 'plugins', 'weather-widget');
-
-      expect(existsSync(join(pluginDir, 'plugin.json'))).toBe(true);
-      expect(existsSync(join(pluginDir, 'index.js'))).toBe(true);
-    });
-  });
-
-  describe('Plugin Loading via WidgetLoader', () => {
-    test('should discover hello-world plugin', async () => {
-      // Copy hello-world to temp dir for testing
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'hello-world');
-      const targetDir = join(tempDir, 'example-hello-world');
-
-      // Create target directory first
-      await mkdir(targetDir, { recursive: true });
-
-      await writeFile(
-        join(targetDir, 'plugin.json'),
-        await readFile(join(sourceDir, 'plugin.json'), 'utf-8')
-      );
-      await writeFile(
-        join(targetDir, 'index.js'),
-        await readFile(join(sourceDir, 'index.js'), 'utf-8')
-      );
-
-      const discovered = await loader.discoverPlugins();
-
-      expect(discovered.some(p => p.id === 'example-hello-world')).toBe(true);
-    });
-
-    test('should register and load hello-world widget', async () => {
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'hello-world');
-
-      // Import the plugin module
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      // Create mock API
-      const mockApi = new PluginAPI();
-
-      // Register the widget
-      const metadata = {
-        id: 'example-hello-world',
-        name: 'Hello World',
-        version: '1.0.0',
-      };
-
-      loader.register('example-hello-world', metadata, async () => {
-        const WidgetClass = pluginModule.default || pluginModule.HelloWidget;
-        const widget = new WidgetClass({
-          api: mockApi,
-          config: { message: 'Hello, Test!' },
-        });
-        return widget;
-      });
-
-      // Load the widget
-      const widget = await loader.load('example-hello-world');
-
-      expect(widget).toBeDefined();
-      expect(widget.name).toBe('Hello World');
-    });
-
-    test('should execute lifecycle hooks for hello-world', async () => {
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'hello-world');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const mockApi = new PluginAPI();
-
-      const WidgetClass = pluginModule.default || pluginModule.HelloWidget;
-      const widget = new WidgetClass({
-        api: mockApi,
-        config: { message: 'Test', showTimestamp: false },
-      });
-
-      // Test init hook
-      const initResult = await widget.init();
-      expect(initResult).toBe(true);
-      expect(widget.loaded).toBe(false); // Not loaded until create
-
-      // Note: create() requires a blessed screen which we can't fully mock in tests
-      // But we can test that the widget structure is correct
-      expect(widget.getData).toBeDefined();
-      expect(widget.render).toBeDefined();
-      expect(widget.destroy).toBeDefined();
-
-      // Test getData
-      const data = await widget.getData();
-      expect(data).toBeDefined();
-      expect(data.message).toBe('Test');
-      expect(data.timestamp).toBeNull(); // showTimestamp is false
-
-      // Test destroy
-      await widget.destroy();
-      expect(widget.loaded).toBe(false);
-    });
-
-    test('should validate widget has required lifecycle methods', async () => {
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'hello-world');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.HelloWidget;
-      const widget = new WidgetClass();
-
-      // Check all required methods exist
-      expect(typeof widget.init).toBe('function');
-      expect(typeof widget.create).toBe('function');
-      expect(typeof widget.getData).toBe('function');
-      expect(typeof widget.render).toBe('function');
-      expect(typeof widget.destroy).toBe('function');
-    });
-  });
-
-  describe('API Status Widget Tests', () => {
-    let originalFetch;
-
-    beforeEach(() => {
-      // Store original fetch
-      originalFetch = globalThis.fetch;
-    });
-
-    afterEach(() => {
-      // Restore original fetch
-      globalThis.fetch = originalFetch;
-    });
-
-    test('should create api-status widget instance', async () => {
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'api-status');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.ApiStatusWidget;
-      const widget = new WidgetClass({
-        config: {
-          apiUrl: 'https://api.github.com/zen',
-          timeout: 5000,
-          retries: 1,
-        },
-      });
-
-      expect(widget.name).toBe('API Status');
-      expect(widget.config.apiUrl).toBe('https://api.github.com/zen');
-    });
-
-    test('should handle getData with custom config', async () => {
-      // Mock fetch to avoid real HTTP requests
-      const mockResponse = {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: new Map([['content-type', 'text/plain']]),
-        json: async () => ({}),
-        text: async () => 'Mock API response',
-      };
-
-      globalThis.fetch = jest.fn().mockResolvedValue(mockResponse);
-
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'api-status');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.ApiStatusWidget;
-      const widget = new WidgetClass({
-        config: {
-          apiUrl: 'https://api.github.com/zen',
-          timeout: 100,
-          retries: 0, // No retries for fast test
-        },
-      });
-
-      // Mock updateStatus to avoid needing UI elements
-      widget.updateStatus = jest.fn();
-
-      const data = await widget.getData();
-
-      // Should succeed with mocked response
-      expect(data).toBeDefined();
-      expect(data).toHaveProperty('success');
-      expect(data).toHaveProperty('timestamp');
-      expect(data).toHaveProperty('apiUrl');
-      expect(globalThis.fetch).toHaveBeenCalled();
-    });
-
-    test('should handle fetch errors gracefully', async () => {
-      // Mock fetch to return an error
-      globalThis.fetch = jest.fn().mockRejectedValue(new Error('Network error'));
-
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'api-status');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.ApiStatusWidget;
-      const widget = new WidgetClass({
-        config: {
-          apiUrl: 'https://api.github.com/zen',
-          timeout: 100,
-          retries: 1,
-        },
-      });
-
-      // Mock updateStatus to avoid needing UI elements
-      widget.updateStatus = jest.fn();
-
-      const data = await widget.getData();
-
-      // Should fail gracefully
-      expect(data).toBeDefined();
-      expect(data.success).toBe(false);
-      expect(data.error).toBeDefined();
-    });
-
-    test('should handle HTTP error responses', async () => {
-      // Mock fetch to return an HTTP error
-      const mockResponse = {
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error',
-        headers: new Map([['content-type', 'application/json']]),
-        json: async () => ({ error: 'Server error' }),
-      };
-
-      globalThis.fetch = jest.fn().mockResolvedValue(mockResponse);
-
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'api-status');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.ApiStatusWidget;
-      const widget = new WidgetClass({
-        config: {
-          apiUrl: 'https://api.github.com/zen',
-          timeout: 100,
-          retries: 0,
-        },
-      });
-
-      // Mock updateStatus to avoid needing UI elements
-      widget.updateStatus = jest.fn();
-
-      const data = await widget.getData();
-
-      // Should fail gracefully with HTTP error
-      expect(data).toBeDefined();
-      expect(data.success).toBe(false);
-      expect(data.error).toContain('500');
-    });
-
-    test('should handle timeout/abort errors', async () => {
-      // Mock fetch to throw AbortError
-      const abortError = new Error('Aborted');
-      abortError.name = 'AbortError';
-
-      globalThis.fetch = jest.fn().mockRejectedValue(abortError);
-
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'api-status');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.ApiStatusWidget;
-      const widget = new WidgetClass({
-        config: {
-          apiUrl: 'https://api.github.com/zen',
-          timeout: 50,
-          retries: 1,
-        },
-      });
-
-      // Mock updateStatus to avoid needing UI elements
-      widget.updateStatus = jest.fn();
-
-      const data = await widget.getData();
-
-      // Should fail gracefully with timeout
-      expect(data).toBeDefined();
-      expect(data.success).toBe(false);
-    });
-  });
-
-  describe('System Metrics Chart Widget Tests', () => {
-    test('should create system-metrics-chart widget instance', async () => {
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'system-metrics-chart');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.SystemMetricsChartWidget;
-      const widget = new WidgetClass({
-        config: {
-          metricType: 'memory',
-          maxDataPoints: 10,
-        },
-      });
-
-      expect(widget.name).toBe('System Metrics Chart');
-      expect(widget.metricType).toBe('memory');
-      expect(widget.maxDataPoints).toBe(10);
-    });
-
-    test('should generate chart data correctly', async () => {
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'system-metrics-chart');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.SystemMetricsChartWidget;
-      const widget = new WidgetClass({
-        config: {
-          metricType: 'cpu',
-          maxDataPoints: 5,
-        },
-      });
-
-      // First getData call
-      const data1 = await widget.getData();
-      expect(data1.labels).toHaveLength(1);
-      expect(data1.values).toHaveLength(1);
-
-      // Second getData call - should accumulate
-      const data2 = await widget.getData();
-      expect(data2.labels).toHaveLength(2);
-      expect(data2.values).toHaveLength(2);
-
-      // After maxDataPoints, should stop accumulating
-      for (let i = 0; i < 10; i++) {
-        await widget.getData();
-      }
-
-      const finalData = await widget.getData();
-      expect(finalData.labels.length).toBeLessThanOrEqual(5);
-      expect(finalData.values.length).toBeLessThanOrEqual(5);
-    });
-  });
-
-  describe('Weather Widget Tests', () => {
-    test('should create weather widget instance', async () => {
-      const sourceDir = join(__dirname, '..', 'examples', 'plugins', 'weather-widget');
-      const pluginPath = join(sourceDir, 'index.js');
-      const pluginModule = await import(pluginPath);
-
-      const WidgetClass = pluginModule.default || pluginModule.WeatherWidget;
-      const widget = new WidgetClass({
-        config: {
-          location: 'New York',
-          unit: 'fahrenheit',
-        },
-      });
-
-      expect(widget.name).toBe('Weather');
-      expect(widget.config.location).toBe('New York');
-      expect(widget.config.unit).toBe('fahrenheit');
-    });
-  });
-});
-
-describe('Plugin Manifest Schema', () => {
-  test('should enforce required fields', () => {
-    const emptyManifest = {};
-
-    expect(() => validateManifest(emptyManifest)).toThrow(/Missing required fields/);
-  });
-
-  test('should require name field', () => {
-    const manifest = {
-      entryPoint: 'index.js',
-    };
-
-    expect(() => validateManifest(manifest)).toThrow(/name/);
-  });
-
-  test('should require entryPoint field (legacy requirement)', () => {
-    const manifest = {
-      name: 'Test',
-      version: '1.0.0',
-    };
-
-    expect(() => validateManifest(manifest)).toThrow(/entryPoint/);
-  });
-
-  test('should accept all required fields', () => {
-    const manifest = {
-      name: 'Test Widget',
-      version: '1.0.0',
-      entryPoint: 'index.js',
-    };
-
-    expect(() => validateManifest(manifest)).not.toThrow();
-  });
-
-  test('should validate semver format', () => {
-    const validVersions = ['1.0.0', '0.0.1', '10.20.30'];
-    const invalidVersions = ['v1.0.0', '1.0', 'latest'];
-
-    for (const version of validVersions) {
-      const manifest = { name: 'Test', version, entryPoint: 'index.js' };
-      expect(() => validateManifest(manifest)).not.toThrow();
-    }
-
-    for (const version of invalidVersions) {
-      const manifest = { name: 'Test', version, entryPoint: 'index.js' };
-      expect(() => validateManifest(manifest)).toThrow(/semver/i);
-    }
-  });
-
-  test('should accept valid categories', () => {
-    const categories = ['system', 'monitoring', 'custom', 'example'];
-
-    for (const category of categories) {
-      const manifest = { name: 'Test', version: '1.0.0', entryPoint: 'index.js', category };
-      expect(() => validateManifest(manifest)).not.toThrow();
-    }
-  });
-});
-
-describe('Plugin Lifecycle Integration', () => {
-  test('should execute full lifecycle', async () => {
-    const mockApi = new PluginAPI();
-
-    // Create a simple test widget
-    class TestWidget extends BaseWidget {
-      constructor(options) {
-        super(options);
-        this.initCalled = false;
-        this.createCalled = false;
-        this.getDataCalled = false;
-        this.renderCalled = false;
-        this.destroyCalled = false;
-      }
-
-      async init() {
-        this.initCalled = true;
-        return true;
-      }
-
-      async create(screen, theme) {
-        this.createCalled = true;
-        this.loaded = true;
-        return this;
-      }
-
-      async getData() {
-        this.getDataCalled = true;
-        return { test: 'data' };
-      }
-
-      render(data) {
-        this.renderCalled = true;
-      }
-
-      async destroy() {
-        this.destroyCalled = true;
-        await super.destroy();
-      }
-    }
-
-    const widget = new TestWidget({ api: mockApi });
-
-    // Execute lifecycle
-    await widget.init();
-    expect(widget.initCalled).toBe(true);
-
-    await widget.create({}, {});
-    expect(widget.createCalled).toBe(true);
-    expect(widget.loaded).toBe(true);
-
-    const data = await widget.getData();
-    expect(widget.getDataCalled).toBe(true);
-    expect(data).toEqual({ test: 'data' });
-
-    widget.render(data);
-    expect(widget.renderCalled).toBe(true);
-
-    await widget.destroy();
-    expect(widget.destroyCalled).toBe(true);
-    expect(widget.loaded).toBe(false);
-  });
-
-  test('should handle errors in lifecycle gracefully', async () => {
-    const mockApi = new PluginAPI();
-
-    class ErrorWidget extends BaseWidget {
-      async getData() {
-        throw new Error('Test error');
-      }
-    }
-
-    const widget = new ErrorWidget({ api: mockApi });
-
-    // Should not throw, should handle error gracefully
-    await expect(widget.getData()).rejects.toThrow('Test error');
-  });
-});