claw-dashboard 2.1.1 → 2.2.0

package/tests/plugin-lifecycle-e2e.test.js

@@ -1,1036 +0,0 @@
-/**
- * End-to-End Plugin Lifecycle Integration Tests
- * Tests the complete plugin load/validate/render cycle
- */
-
-import { jest } from '@jest/globals';
-import { fileURLToPath } from 'url';
-import { dirname, join, resolve } from 'path';
-import { existsSync, mkdirSync, writeFileSync, rmSync, readdirSync } from 'fs';
-import os from 'os';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Mock logger to reduce noise in tests
-jest.unstable_mockModule('../src/logger.js', () => ({
-  default: {
-    info: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-    debug: jest.fn(),
-  },
-}));
-
-// Import modules after mocking
-const { default: logger } = await import('../src/logger.js');
-const { WidgetLoader } = await import('../src/widgets/widget-loader.js');
-const { validateManifest, validateManifestFile } = await import('../src/plugin-manifest-validator.js');
-const { runValidatePluginCli } = await import('../src/cli/validate-plugin.js');
-const { PluginError, PLUGIN_ERROR_CODES } = await import('../src/plugin-errors.js');
-
-describe('Plugin Lifecycle E2E Tests', () => {
-  let testDir;
-  let widgetLoader;
-  let originalCwd;
-  let testCounter = 0;
-
-  beforeAll(() => {
-    originalCwd = process.cwd();
-  });
-
-  beforeEach(() => {
-    // Create temporary test directory with unique ID
-    const uniqueId = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}-${++testCounter}`;
-    testDir = join(os.tmpdir(), `claw-test-${uniqueId}`);
-    mkdirSync(testDir, { recursive: true });
-
-    // Create a package.json with type: module so ES Modules work in temp directory
-    writeFileSync(
-      join(testDir, 'package.json'),
-      JSON.stringify({ type: 'module' }, null, 2)
-    );
-
-    // Create widget loader with test directories
-    widgetLoader = new WidgetLoader({
-      widgetsDir: join(testDir, 'widgets'),
-      pluginsDir: join(testDir, 'plugins'),
-    });
-
-    // Create plugins directory
-    mkdirSync(join(testDir, 'plugins'), { recursive: true });
-
-    jest.clearAllMocks();
-  });
-
-  afterEach(async () => {
-    // Cleanup test directory
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true, force: true });
-    }
-
-    // Clear widget loader
-    if (widgetLoader) {
-      await widgetLoader.clear();
-    }
-  });
-
-  afterAll(() => {
-    process.chdir(originalCwd);
-  });
-
-  // ============================================================================
-  // HELPER FUNCTIONS
-  // ============================================================================
-
-  /**
-   * Create a test plugin directory with manifest and code.
-   * Uses unique directory names to avoid ES Module caching between tests.
-   */
-  function createTestPlugin(pluginName, manifest, code) {
-    // Use unique directory name to avoid ES Module caching
-    const uniqueDirName = `${pluginName}-${testCounter}-${Date.now()}`;
-    const pluginDir = join(testDir, 'plugins', uniqueDirName);
-    mkdirSync(pluginDir, { recursive: true });
-
-    // Write manifest
-    writeFileSync(join(pluginDir, 'plugin.json'), JSON.stringify(manifest, null, 2));
-
-    // Write code if provided
-    if (code) {
-      writeFileSync(join(pluginDir, 'index.js'), code);
-    }
-
-    return pluginDir;
-  }
-
-  /**
-   * Create a minimal valid widget plugin
-   */
-  function createMinimalWidget(name, options = {}) {
-    const manifest = {
-      id: options.id || name,
-      name: options.name || name,
-      version: options.version || '1.0.0',
-      type: 'widget',
-      category: options.category || 'custom',
-      description: options.description || 'Test widget',
-      author: options.author || 'Test Author',
-      lazyLoad: options.lazyLoad !== undefined ? options.lazyLoad : false, // Default to eager loading for tests
-      ...options.manifestExtra,
-    };
-
-    // Ensure category is a valid enum value
-    const validCategories = ['system', 'monitoring', 'custom', 'example'];
-    if (!validCategories.includes(manifest.category)) {
-      manifest.category = 'custom';
-    }
-
-    const code = options.code || `
-      export default class TestWidget {
-        constructor(config) {
-          this.config = config || {};
-          this.data = { value: 42 };
-        }
-
-        async init() {
-          return { success: true };
-        }
-
-        async getData() {
-          return this.data;
-        }
-
-        render() {
-          return 'TestWidget rendered';
-        }
-
-        async destroy() {
-          // Cleanup
-        }
-
-        getWidgetConfig() {
-          return {
-            refreshInterval: 5000,
-            priority: ${options.priority || 100},
-          };
-        }
-      }
-    `;
-
-    return { manifest, code };
-  }
-
-  // ============================================================================
-  // PLUGIN DISCOVERY TESTS
-  // ============================================================================
-
-  describe('Plugin Discovery', () => {
-    test('should discover plugins from plugins directory', async () => {
-      // Create multiple test plugins
-      const plugin1 = createMinimalWidget('test-widget-1');
-      createTestPlugin('test-widget-1', plugin1.manifest, plugin1.code);
-
-      const plugin2 = createMinimalWidget('test-widget-2');
-      createTestPlugin('test-widget-2', plugin2.manifest, plugin2.code);
-
-      // Discover plugins
-      const discovered = await widgetLoader.discoverPlugins();
-
-      expect(discovered).toHaveLength(2);
-      expect(discovered.map(p => p.id)).toContain('test-widget-1');
-      expect(discovered.map(p => p.id)).toContain('test-widget-2');
-    });
-
-    test('should skip non-widget type plugins', async () => {
-      // Create a widget plugin
-      const widgetPlugin = createMinimalWidget('test-widget');
-      createTestPlugin('test-widget', widgetPlugin.manifest, widgetPlugin.code);
-
-      // Create a non-widget plugin
-      const nonWidgetManifest = {
-        id: 'test-theme',
-        name: 'Test Theme',
-        version: '1.0.0',
-        type: 'theme',
-        description: 'Test theme plugin',
-      };
-      createTestPlugin('test-theme', nonWidgetManifest, 'export default {}');
-
-      const discovered = await widgetLoader.discoverPlugins();
-
-      expect(discovered).toHaveLength(1);
-      expect(discovered[0].id).toBe('test-widget');
-    });
-
-    test('should skip plugins with invalid directory names', async () => {
-      // Create a plugin with invalid name
-      const plugin = createMinimalWidget('test-widget');
-      createTestPlugin('../malicious', plugin.manifest, plugin.code);
-
-      const discovered = await widgetLoader.discoverPlugins();
-
-      // Should skip the malicious directory
-      expect(discovered).toHaveLength(0);
-    });
-
-    test('should skip plugins without required files', async () => {
-      // Create a plugin with only manifest (no index.js)
-      const plugin = createMinimalWidget('test-widget');
-      const pluginDir = join(testDir, 'plugins', 'test-widget');
-      mkdirSync(pluginDir, { recursive: true });
-      writeFileSync(join(pluginDir, 'plugin.json'), JSON.stringify(plugin.manifest, null, 2));
-      // Intentionally NOT creating index.js
-
-      const discovered = await widgetLoader.discoverPlugins();
-
-      expect(discovered).toHaveLength(0);
-    });
-
-    test('should handle empty plugins directory', async () => {
-      const discovered = await widgetLoader.discoverPlugins();
-      expect(discovered).toHaveLength(0);
-    });
-
-    test('should handle missing plugins directory gracefully', async () => {
-      // Remove plugins directory
-      rmSync(join(testDir, 'plugins'), { recursive: true, force: true });
-
-      // Should return empty array, not throw
-      const discovered = await widgetLoader.discoverPlugins();
-      expect(discovered).toHaveLength(0);
-    });
-  });
-
-  // ============================================================================
-  // PLUGIN VALIDATION TESTS
-  // ============================================================================
-
-  describe('Plugin Validation', () => {
-    test('should validate a valid plugin manifest', () => {
-      const manifest = {
-        id: 'test-widget',
-        name: 'Test Widget',
-        version: '1.0.0',
-        type: 'widget',
-        description: 'A test widget',
-        author: 'Test Author',
-        category: 'custom',
-      };
-
-      const result = validateManifest(manifest);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    test('should reject invalid plugin manifest', () => {
-      const manifest = {
-        id: 'test-widget',
-        name: '', // Invalid: empty name
-        version: 'invalid', // Invalid: not semver
-        type: 'unknown', // Invalid: not in enum
-      };
-
-      const result = validateManifest(manifest);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-
-    test('should detect missing required fields', () => {
-      const manifest = {
-        id: 'test-widget',
-        // Missing name, version, type
-      };
-
-      const result = validateManifest(manifest);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors.some(e => e.includes('name'))).toBe(true);
-      expect(result.errors.some(e => e.includes('version'))).toBe(true);
-      expect(result.errors.some(e => e.includes('type'))).toBe(true);
-    });
-
-    test('should validate plugin via CLI', async () => {
-      const plugin = createMinimalWidget('cli-test-widget');
-      const pluginDir = createTestPlugin('cli-test-widget', plugin.manifest, plugin.code);
-
-      const exitCode = await runValidatePluginCli([pluginDir]);
-
-      expect(exitCode).toBe(0);
-    });
-
-    test('should reject invalid plugin via CLI', async () => {
-      const invalidManifest = {
-        id: 'invalid-widget',
-        name: '', // Invalid
-        version: 'bad', // Invalid
-        type: 'widget',
-      };
-      const pluginDir = createTestPlugin('invalid-widget', invalidManifest, 'export default {}');
-
-      const exitCode = await runValidatePluginCli([pluginDir]);
-
-      expect(exitCode).toBe(1);
-    });
-
-    test('should validate plugin with complex config', () => {
-      const manifest = {
-        id: 'config-widget',
-        name: 'Config Widget',
-        version: '1.0.0',
-        type: 'widget',
-        category: 'custom',
-        description: 'Widget with config',
-        author: 'Test Author',
-        config: {
-          refreshInterval: {
-            type: 'number',
-            default: 5000,
-            min: 1000,
-            max: 60000,
-          },
-          theme: {
-            type: 'string',
-            default: 'default',
-            options: ['default', 'dark', 'light'],
-          },
-          enabled: {
-            type: 'boolean',
-            default: true,
-          },
-        },
-      };
-
-      const result = validateManifest(manifest);
-
-      expect(result.valid).toBe(true);
-    });
-  });
-
-  // ============================================================================
-  // PLUGIN LOADING TESTS
-  // ============================================================================
-
-  describe('Plugin Loading', () => {
-    test('should load a valid plugin', async () => {
-      const plugin = createMinimalWidget('loadable-widget');
-      const pluginDir = createTestPlugin('loadable-widget', plugin.manifest, plugin.code);
-
-      const id = await widgetLoader.loadPlugin(pluginDir);
-
-      expect(id).toBe('loadable-widget');
-      // With lazy loading, isLoaded() returns true after loadPlugin() because it auto-loads
-      expect(widgetLoader.isLoaded('loadable-widget')).toBe(true);
-    });
-
-    test('should fail to load plugin with invalid manifest', async () => {
-      const invalidManifest = {
-        id: 'bad-manifest',
-        name: '', // Invalid
-        version: '1.0.0',
-        type: 'widget',
-      };
-      const pluginDir = createTestPlugin('bad-manifest', invalidManifest, 'export default {}');
-
-      // Should return null with fallbackOnError (default)
-      const id = await widgetLoader.loadPlugin(pluginDir);
-      expect(id).toBeNull();
-    });
-
-    test('should fail to load plugin with missing entry point', async () => {
-      const plugin = createMinimalWidget('no-entry');
-      const pluginDir = join(testDir, 'plugins', 'no-entry');
-      mkdirSync(pluginDir, { recursive: true });
-      writeFileSync(join(pluginDir, 'plugin.json'), JSON.stringify(plugin.manifest, null, 2));
-      // Don't create index.js
-
-      const id = await widgetLoader.loadPlugin(pluginDir);
-      expect(id).toBeNull();
-    });
-
-    test('should load multiple plugins', async () => {
-      const plugin1 = createMinimalWidget('multi-1');
-      const plugin2 = createMinimalWidget('multi-2');
-
-      createTestPlugin('multi-1', plugin1.manifest, plugin1.code);
-      createTestPlugin('multi-2', plugin2.manifest, plugin2.code);
-
-      const results = await widgetLoader.loadAllPluginsWithFallback();
-
-      expect(results.successful).toContain('multi-1');
-      expect(results.successful).toContain('multi-2');
-      expect(results.failed).toHaveLength(0);
-    });
-
-    test('should handle partial loading with some failures', async () => {
-      const goodPlugin = createMinimalWidget('good-widget');
-      const badManifest = {
-        id: 'bad-widget',
-        name: '', // Invalid - will fail validation
-        version: '1.0.0',
-        type: 'widget',
-        author: 'Test Author',
-        category: 'custom',
-      };
-
-      createTestPlugin('good-widget', goodPlugin.manifest, goodPlugin.code);
-      createTestPlugin('bad-widget', badManifest, 'export default {}');
-
-      const results = await widgetLoader.loadAllPluginsWithFallback();
-
-      // Only the good widget should be successfully loaded
-      expect(results.successful).toContain('good-widget');
-      // The bad widget fails validation during discovery and is never registered
-      expect(results.successful).not.toContain('bad-widget');
-    });
-
-    test('should unload a loaded plugin', async () => {
-      const plugin = createMinimalWidget('unloadable');
-      const pluginDir = createTestPlugin('unloadable', plugin.manifest, plugin.code);
-
-      const id = await widgetLoader.loadPlugin(pluginDir);
-      expect(id).toBe('unloadable');
-
-      // Load the widget instance
-      const instance = await widgetLoader.load('unloadable');
-      expect(instance).not.toBeNull();
-      expect(widgetLoader.isLoaded('unloadable')).toBe(true);
-
-      const unloaded = await widgetLoader.unload('unloadable');
-      expect(unloaded).toBe(true);
-      expect(widgetLoader.isLoaded('unloadable')).toBe(false);
-    });
-
-    test('should support lazy loading', async () => {
-      const plugin = createMinimalWidget('lazy-widget', {
-        manifestExtra: { lazyLoad: true },
-      });
-      const pluginDir = createTestPlugin('lazy-widget', plugin.manifest, plugin.code);
-
-      // Register only (lazy)
-      await widgetLoader.loadPlugin(pluginDir, { fallbackOnError: true });
-
-      // Should be registered but not loaded
-      expect(widgetLoader.widgetRegistry.has('lazy-widget')).toBe(true);
-    });
-
-    test('should load plugins with dependencies in correct order', async () => {
-      // Create parent plugin
-      const parent = createMinimalWidget('parent-widget');
-      createTestPlugin('parent-widget', parent.manifest, parent.code);
-
-      // Create child plugin with dependency
-      const child = createMinimalWidget('child-widget', {
-        manifestExtra: { dependencies: ['parent-widget'] },
-      });
-      createTestPlugin('child-widget', child.manifest, child.code);
-
-      // Load plugins with dependency resolution
-      const results = await widgetLoader.loadAllPluginsWithFallback({
-        resolveDependencies: true,
-      });
-
-      expect(results.successful).toContain('parent-widget');
-      expect(results.successful).toContain('child-widget');
-    });
-  });
-
-  // ============================================================================
-  // WIDGET RENDER LIFECYCLE TESTS
-  // ============================================================================
-
-  describe('Widget Render Lifecycle', () => {
-    test('should complete full widget lifecycle: init -> getData -> render -> destroy', async () => {
-      const plugin = createMinimalWidget('lifecycle-widget', {
-        code: `
-          export default class LifecycleWidget {
-            constructor(config) {
-              this.config = config;
-              this.initCalled = false;
-              this.data = { status: 'ready', counter: 0 };
-            }
-
-            async init() {
-              this.initCalled = true;
-              return { success: true };
-            }
-
-            async getData() {
-              this.data.counter++;
-              return this.data;
-            }
-
-            render(data) {
-              if (!this.initCalled) {
-                throw new Error('init not called before render');
-              }
-              return { content: 'Rendered: ' + JSON.stringify(data || this.data) };
-            }
-
-            async destroy() {
-              this.data = null;
-            }
-          }
-        `,
-      });
-
-      const pluginDir = createTestPlugin('lifecycle-widget', plugin.manifest, plugin.code);
-      await widgetLoader.loadPlugin(pluginDir);
-
-      // Load the widget instance to get the actual widget object
-      const instance = await widgetLoader.load('lifecycle-widget');
-      expect(instance).toBeDefined();
-      expect(instance).not.toBeNull();
-
-      // Test init
-      const initResult = await instance.init();
-      expect(initResult.success).toBe(true);
-      expect(instance.initCalled).toBe(true);
-
-      // Test getData
-      const data = await instance.getData();
-      expect(data.status).toBe('ready');
-      expect(data.counter).toBe(1);
-
-      // Test render
-      const renderResult = instance.render(data);
-      expect(renderResult.content).toContain('Rendered:');
-      expect(renderResult.content).toContain('ready');
-
-      // Test destroy
-      await instance.destroy();
-      expect(instance.data).toBeNull();
-    });
-
-    test('should handle widget that requires render after getData', async () => {
-      const plugin = createMinimalWidget('render-flow', {
-        code: `
-          export default class RenderFlowWidget {
-            constructor(config) {
-              this.config = config;
-              this.cachedData = null;
-            }
-
-            async getData() {
-              this.cachedData = { timestamp: Date.now(), value: 'test' };
-              return this.cachedData;
-            }
-
-            render() {
-              if (!this.cachedData) {
-                throw new Error('getData must be called before render');
-              }
-              return { rendered: true, data: this.cachedData };
-            }
-          }
-        `,
-      });
-
-      const pluginDir = createTestPlugin('render-flow', plugin.manifest, plugin.code);
-      await widgetLoader.loadPlugin(pluginDir);
-
-      // Load the widget instance
-      const instance = await widgetLoader.load('render-flow');
-      expect(instance).toBeDefined();
-      expect(instance).not.toBeNull();
-
-      // Should throw if render called before getData
-      expect(() => instance.render()).toThrow('getData must be called');
-
-      // Should work after getData
-      await instance.getData();
-      const result = instance.render();
-      expect(result.rendered).toBe(true);
-    });
-
-    test('should handle widgets with config', async () => {
-      const plugin = createMinimalWidget('config-widget', {
-        manifestExtra: {
-          config: {
-            title: { type: 'string', default: 'Default Title' },
-            refreshInterval: { type: 'number', default: 5000 },
-          },
-        },
-        code: `
-          export default class ConfigWidget {
-            constructor(config) {
-              this.config = config || {};
-            }
-
-            getWidgetConfig() {
-              return {
-                title: this.config.title || 'Default Title',
-                refreshInterval: this.config.refreshInterval || 5000,
-              };
-            }
-
-            async getData() {
-              return {
-                config: this.getWidgetConfig(),
-              };
-            }
-
-            render() {
-              const cfg = this.getWidgetConfig();
-              return { title: cfg.title };
-            }
-          }
-        `,
-      });
-
-      const pluginDir = createTestPlugin('config-widget', plugin.manifest, plugin.code);
-      await widgetLoader.loadPlugin(pluginDir);
-
-      // Load the widget instance
-      const instance = await widgetLoader.load('config-widget');
-      expect(instance).toBeDefined();
-      expect(instance).not.toBeNull();
-
-      const config = instance.getWidgetConfig();
-
-      expect(config.title).toBe('Default Title');
-      expect(config.refreshInterval).toBe(5000);
-    });
-
-    test('should support widgets with multiple render cycles', async () => {
-      const plugin = createMinimalWidget('multi-render', {
-        code: `
-          export default class MultiRenderWidget {
-            constructor(config) {
-              this.config = config;
-              this.renderCount = 0;
-            }
-
-            async getData() {
-              this.renderCount++;
-              return { count: this.renderCount };
-            }
-
-            render(data) {
-              return { cycle: data.count, rendered: true };
-            }
-          }
-        `,
-      });
-
-      const pluginDir = createTestPlugin('multi-render', plugin.manifest, plugin.code);
-      await widgetLoader.loadPlugin(pluginDir);
-
-      // Load the widget instance using load() not get()
-      const instance = await widgetLoader.load('multi-render');
-      expect(instance).not.toBeNull();
-
-      // Simulate multiple render cycles
-      for (let i = 1; i <= 3; i++) {
-        const data = await instance.getData();
-        const result = instance.render(data);
-        expect(result.cycle).toBe(i);
-      }
-    });
-  });
-
-  // ============================================================================
-  // ERROR HANDLING TESTS
-  // ============================================================================
-
-  describe('Error Handling and Edge Cases', () => {
-    // SKIPPED: Syntax error handling cannot be tested with Jest's ESM implementation
-    // VM-level SyntaxErrors during dynamic import cannot be caught by try-catch
-    // and crash the test process. This is a known limitation.
-    // In production, syntax errors would be caught by fallbackOnError.
-    test.skip('should handle plugin with syntax error in entry point', async () => {
-      const manifest = {
-        id: 'syntax-error',
-        name: 'Syntax Error Widget',
-        version: '1.0.0',
-        type: 'widget',
-        author: 'Test Author',
-        category: 'custom',
-        description: 'Test widget with syntax error',
-      };
-      const badCode = `
-        export default class BadWidget {
-          constructor(config) {  // Missing closing brace
-            this.config = config
-        // Syntax error!
-      `;
-
-      const pluginDir = createTestPlugin('syntax-error', manifest, badCode);
-
-      // With fallbackOnError, loadPlugin should return the ID even if loading fails
-      const id = await widgetLoader.loadPlugin(pluginDir);
-      expect(id).toBe('syntax-error');
-    });
-
-    test('should handle widget with missing required methods', async () => {
-      const manifest = {
-        id: 'incomplete',
-        name: 'Incomplete Widget',
-        version: '1.0.0',
-        type: 'widget',
-      };
-      const incompleteCode = `
-        export default class IncompleteWidget {
-          constructor(config) {
-            this.config = config;
-          }
-          // Missing getData and render methods
-        }
-      `;
-
-      const pluginDir = createTestPlugin('incomplete', manifest, incompleteCode);
-
-      // Should fail validation when trying to load
-      const id = await widgetLoader.registerPlugin(pluginDir);
-
-      // Try to load - should fail validation
-      await expect(widgetLoader.load('incomplete')).rejects.toThrow();
-    });
-
-    test('should handle plugin with circular dependencies', async () => {
-      const pluginA = createMinimalWidget('circular-a', {
-        manifestExtra: { dependencies: ['circular-b'] },
-      });
-      const pluginB = createMinimalWidget('circular-b', {
-        manifestExtra: { dependencies: ['circular-a'] },
-      });
-
-      createTestPlugin('circular-a', pluginA.manifest, pluginA.code);
-      createTestPlugin('circular-b', pluginB.manifest, pluginB.code);
-
-      const results = await widgetLoader.loadAllPluginsWithFallback({
-        resolveDependencies: true,
-      });
-
-      // Should detect circular dependency
-      expect(results.dependencyErrors.length).toBeGreaterThan(0);
-    });
-
-    test('should handle plugin with missing dependency', async () => {
-      const plugin = createMinimalWidget('missing-dep', {
-        manifestExtra: { dependencies: ['non-existent-widget'] },
-      });
-
-      createTestPlugin('missing-dep', plugin.manifest, plugin.code);
-
-      const results = await widgetLoader.loadAllPluginsWithFallback({
-        resolveDependencies: true,
-      });
-
-      // Missing dependency errors are recorded in dependencyErrors
-      expect(results.dependencyErrors.length).toBeGreaterThan(0);
-    });
-
-    test('should handle malformed plugin.json', async () => {
-      const pluginDir = join(testDir, 'plugins', 'malformed-json');
-      mkdirSync(pluginDir, { recursive: true });
-      writeFileSync(join(pluginDir, 'plugin.json'), '{ invalid json }');
-      writeFileSync(join(pluginDir, 'index.js'), 'export default {}');
-
-      const discovered = await widgetLoader.discoverPlugins();
-      expect(discovered).toHaveLength(0);
-    });
-
-    test('should handle plugin with invalid ID format', async () => {
-      const manifest = {
-        id: 'Invalid ID With Spaces!', // Invalid ID format
-        name: 'Bad ID Widget',
-        version: '1.0.0',
-        type: 'widget',
-      };
-
-      const result = validateManifest(manifest);
-      // ID validation may be strict depending on schema
-      // The schema should reject invalid ID patterns
-    });
-
-    test('should handle concurrent loading attempts', async () => {
-      const plugin = createMinimalWidget('concurrent');
-      const pluginDir = createTestPlugin('concurrent', plugin.manifest, plugin.code);
-
-      // Start multiple concurrent loads
-      const loads = [
-        widgetLoader.loadPlugin(pluginDir),
-        widgetLoader.loadPlugin(pluginDir),
-        widgetLoader.loadPlugin(pluginDir),
-      ];
-
-      // Should handle gracefully (not crash)
-      const results = await Promise.all(loads);
-      expect(results.every(r => r === 'concurrent' || r === null)).toBe(true);
-    });
-
-    test('should handle plugin that throws during init', async () => {
-      const plugin = createMinimalWidget('failing-init', {
-        code: `
-          export default class FailingInitWidget {
-            constructor(config) {
-              this.config = config;
-            }
-
-            async init() {
-              throw new Error('Init failed');
-            }
-
-            async getData() {
-              return {};
-            }
-
-            render() {
-              return 'rendered';
-            }
-          }
-        `,
-      });
-
-      const pluginDir = createTestPlugin('failing-init', plugin.manifest, plugin.code);
-      await widgetLoader.loadPlugin(pluginDir);
-
-      // Load the widget instance - init() is not called during load, so this succeeds
-      const instance = await widgetLoader.load('failing-init');
-      expect(instance).toBeDefined();
-      expect(instance).not.toBeNull();
-
-      // init should throw
-      await expect(instance.init()).rejects.toThrow('Init failed');
-    });
-
-    test('should handle plugin that throws during getData', async () => {
-      const plugin = createMinimalWidget('failing-getdata', {
-        code: `
-          export default class FailingGetDataWidget {
-            constructor(config) {
-              this.config = config;
-            }
-
-            async getData() {
-              throw new Error('Data fetch failed');
-            }
-
-            render() {
-              return 'rendered';
-            }
-          }
-        `,
-      });
-
-      const pluginDir = createTestPlugin('failing-getdata', plugin.manifest, plugin.code);
-      await widgetLoader.loadPlugin(pluginDir);
-
-      // Load the widget instance
-      const instance = await widgetLoader.load('failing-getdata');
-      expect(instance).toBeDefined();
-      expect(instance).not.toBeNull();
-
-      await expect(instance.getData()).rejects.toThrow('Data fetch failed');
-    });
-
-    test('should handle cleanup on unload failure', async () => {
-      const plugin = createMinimalWidget('failing-destroy', {
-        code: `
-          export default class FailingDestroyWidget {
-            constructor(config) {
-              this.config = config;
-            }
-
-            async getData() {
-              return {};
-            }
-
-            render() {
-              return 'rendered';
-            }
-
-            async destroy() {
-              throw new Error('Destroy failed');
-            }
-          }
-        `,
-
-      });
-
-      const pluginDir = createTestPlugin('failing-destroy', plugin.manifest, plugin.code);
-      const id = await widgetLoader.loadPlugin(pluginDir);
-      expect(id).toBe('failing-destroy');
-
-      // Widget should be registered (even if loading failed)
-      expect(widgetLoader.widgetRegistry.has('failing-destroy')).toBe(true);
-
-      // Try to unload - returns false if widget not loaded, true if unloaded
-      const unloaded = await widgetLoader.unload('failing-destroy');
-      // unload returns false if widget was never successfully loaded
-      expect(typeof unloaded).toBe('boolean');
-    });
-
-    test('should provide meaningful error context', async () => {
-      const manifest = {
-        id: 'error-context',
-        name: '', // Invalid - will cause validation failure
-        version: '1.0.0',
-        type: 'widget',
-      };
-
-      const result = validateManifest(manifest);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-  });
-
-  // ============================================================================
-  // INTEGRATION TESTS
-  // ============================================================================
-
-  describe('Full Integration Flow', () => {
-    test('should complete full E2E workflow: discover -> validate -> load -> render', async () => {
-      // Create multiple widgets with different characteristics
-      const widgetA = createMinimalWidget('widget-a', {
-        priority: 10,
-        description: 'High priority widget',
-      });
-      const widgetB = createMinimalWidget('widget-b', {
-        priority: 50,
-        description: 'Medium priority widget',
-        manifestExtra: { lazyLoad: false },
-      });
-
-      createTestPlugin('widget-a', widgetA.manifest, widgetA.code);
-      createTestPlugin('widget-b', widgetB.manifest, widgetB.code);
-
-      // Step 1: Discover
-      const discovered = await widgetLoader.discoverPlugins();
-      expect(discovered).toHaveLength(2);
-
-      // Step 2: Validate all discovered plugins
-      for (const plugin of discovered) {
-        const validation = validateManifest(plugin.manifest);
-        expect(validation.valid).toBe(true);
-      }
-
-      // Step 3: Load all plugins
-      const results = await widgetLoader.loadAllPluginsWithFallback();
-
-      // Check that plugins were discovered and registered
-      // Note: actual loading may fail due to test environment constraints
-      expect(results.successful.length + results.failed.length + results.skipped.length)
-        .toBeGreaterThanOrEqual(0);
-
-      // Step 4: For any successfully loaded widgets, render them
-      for (const id of results.successful) {
-        // Load the widget instance explicitly
-        const instance = await widgetLoader.load(id).catch(() => null);
-        if (!instance) continue;
-
-        expect(typeof instance.getData).toBe('function');
-        expect(typeof instance.render).toBe('function');
-
-        const data = await instance.getData();
-        const rendered = instance.render(data);
-        expect(rendered).toBeDefined();
-      }
-
-      // Step 5: Get loader stats
-      const stats = widgetLoader.getStats();
-      expect(stats.total).toBeGreaterThan(0);
-    });
-
-    test('should handle complex dependency chain', async () => {
-      // Create a chain: A -> B -> C (C depends on B, B depends on A)
-      const widgetA = createMinimalWidget('dep-a');
-      const widgetB = createMinimalWidget('dep-b', {
-        manifestExtra: { dependencies: ['dep-a'] },
-      });
-      const widgetC = createMinimalWidget('dep-c', {
-        manifestExtra: { dependencies: ['dep-b'] },
-      });
-
-      createTestPlugin('dep-a', widgetA.manifest, widgetA.code);
-      createTestPlugin('dep-b', widgetB.manifest, widgetB.code);
-      createTestPlugin('dep-c', widgetC.manifest, widgetC.code);
-
-      // Load with dependency resolution
-      const results = await widgetLoader.loadAllPluginsWithFallback({
-        resolveDependencies: true,
-      });
-
-      expect(results.successful).toContain('dep-a');
-      expect(results.successful).toContain('dep-b');
-      expect(results.successful).toContain('dep-c');
-
-      // Get dependency info
-      const depInfo = widgetLoader.getDependencyInfo('dep-c');
-      expect(depInfo.allDependencies).toContain('dep-a');
-      expect(depInfo.allDependencies).toContain('dep-b');
-    });
-
-    test('should handle plugin hot-reload scenario', async () => {
-      // Initial load
-      const v1 = createMinimalWidget('hot-reload', { version: '1.0.0' });
-      const pluginDir = createTestPlugin('hot-reload', v1.manifest, v1.code);
-
-      const id = await widgetLoader.loadPlugin(pluginDir);
-      expect(id).toBe('hot-reload');
-
-      // Widget should be registered
-      expect(widgetLoader.widgetRegistry.has('hot-reload')).toBe(true);
-
-      // Try to get the loaded instance (may be null if loading failed)
-      const instance = await widgetLoader.load('hot-reload').catch(() => null);
-      if (instance) {
-        expect(widgetLoader.isLoaded('hot-reload')).toBe(true);
-      }
-
-      // Simulate update (in real scenario, file watcher would trigger this)
-      const v2 = createMinimalWidget('hot-reload', { version: '2.0.0' });
-      writeFileSync(join(pluginDir, 'plugin.json'), JSON.stringify(v2.manifest, null, 2));
-
-      // Re-discover should see the update
-      const discovered = await widgetLoader.discoverPlugins();
-      const found = discovered.find(p => p.id === 'hot-reload');
-      expect(found).toBeDefined();
-      expect(found.manifest.version).toBe('2.0.0');
-    });
-  });
-});