claw-dashboard 2.1.0 → 2.2.0

package/tests/cache.test.js

@@ -1,317 +0,0 @@
-/**
- * Tests for cache module
- * TTL cache, getOrFetch, debounce/throttle utilities
- */
-
-import {
-  get,
-  set,
-  getOrFetch,
-  invalidate,
-  clear,
-  getStatus,
-  debounce,
-  throttle,
-} from '../src/cache.js';
-
-describe('cache', () => {
-  beforeEach(() => {
-    // Clear cache before each test
-    clear();
-  });
-
-  describe('get', () => {
-    test('should return null for missing key', () => {
-      expect(get('nonexistent')).toBeNull();
-    });
-
-    test('should return null for expired entry', async () => {
-      set('test', 'value', 10); // Very short TTL
-      await new Promise(resolve => setTimeout(resolve, 20));
-      expect(get('test')).toBeNull();
-    });
-
-    test('should return value for valid cache entry', () => {
-      set('test', 'value', 5000);
-      expect(get('test')).toBe('value');
-    });
-
-    test('should handle different value types', () => {
-      set('string', 'hello');
-      set('number', 42);
-      set('boolean', true);
-      set('object', { key: 'value' });
-      set('array', [1, 2, 3]);
-
-      expect(get('string')).toBe('hello');
-      expect(get('number')).toBe(42);
-      expect(get('boolean')).toBe(true);
-      expect(get('object')).toEqual({ key: 'value' });
-      expect(get('array')).toEqual([1, 2, 3]);
-    });
-
-    test('should handle null values', () => {
-      set('null', null, 5000);
-      expect(get('null')).toBeNull();
-    });
-
-    test('should handle undefined values', () => {
-      set('undefined', undefined, 5000);
-      expect(get('undefined')).toBeUndefined();
-    });
-  });
-
-  describe('set', () => {
-    test('should store value with TTL', () => {
-      set('key', 'value', 1000);
-      expect(get('key')).toBe('value');
-    });
-
-    test('should use default TTL from config', () => {
-      set('key', 'value'); // No TTL specified
-      expect(get('key')).toBe('value');
-    });
-
-    test('should overwrite existing entry', () => {
-      set('key', 'old');
-      set('key', 'new');
-      expect(get('key')).toBe('new');
-    });
-  });
-
-  describe('getOrFetch', () => {
-    test('should return cached value if available', async () => {
-      set('key', 'cached', 5000);
-      const mockFetcher = () => Promise.resolve('should-not-be-called');
-      const result = await getOrFetch('key', mockFetcher);
-      expect(result).toBe('cached');
-    });
-
-    test('should fetch data on cache miss', async () => {
-      const mockFetcher = () => Promise.resolve('fresh');
-      const result = await getOrFetch('key', mockFetcher);
-
-      expect(result).toBe('fresh');
-    });
-
-    test('should cache fetched data', async () => {
-      let callCount = 0;
-      const mockFetcher = () => {
-        callCount++;
-        return Promise.resolve('fresh');
-      };
-      await getOrFetch('key', mockFetcher);
-
-      // Second call should use cache
-      const result = await getOrFetch('key', mockFetcher);
-      expect(result).toBe('fresh');
-      expect(callCount).toBe(1);
-    });
-
-    test('should use custom TTL when provided', async () => {
-      let callCount = 0;
-      const mockFetcher = () => {
-        callCount++;
-        return Promise.resolve('value');
-      };
-      await getOrFetch('key', mockFetcher, 50);
-
-      // Wait for TTL to expire
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      // Fetcher should be called again
-      const result = await getOrFetch('key', mockFetcher);
-
-      expect(result).toBe('value');
-      expect(callCount).toBe(2);
-    });
-
-    test('should handle async fetcher errors', async () => {
-      const mockFetcher = () => Promise.reject(new Error('fetch failed'));
-
-      await expect(getOrFetch('key', mockFetcher)).rejects.toThrow('fetch failed');
-    });
-  });
-
-  describe('invalidate', () => {
-    test('should remove specific cache entry', () => {
-      set('key1', 'value1');
-      set('key2', 'value2');
-
-      invalidate('key1');
-
-      expect(get('key1')).toBeNull();
-      expect(get('key2')).toBe('value2');
-    });
-
-    test('should handle invalidating non-existent key', () => {
-      expect(() => invalidate('nonexistent')).not.toThrow();
-    });
-  });
-
-  describe('clear', () => {
-    test('should remove all cache entries', () => {
-      set('key1', 'value1');
-      set('key2', 'value2');
-
-      clear();
-
-      expect(get('key1')).toBeNull();
-      expect(get('key2')).toBeNull();
-    });
-
-    test('should work on empty cache', () => {
-      expect(() => clear()).not.toThrow();
-    });
-  });
-
-  describe('getStatus', () => {
-    test('should return empty object for empty cache', () => {
-      const status = getStatus();
-      expect(status).toEqual({});
-    });
-
-    test('should return status for cached entries', () => {
-      set('key', 'value', 5000);
-
-      const status = getStatus();
-
-      expect(status.key).toBeDefined();
-      expect(status.key.cached).toBe(true);
-      expect(status.key.age).toBeDefined();
-      expect(status.key.ttlRemaining).toBeDefined();
-      expect(status.key.configTtl).toBeDefined();
-    });
-
-    test('should show remaining TTL', async () => {
-      set('key', 'value', 200);
-
-      const statusBefore = getStatus();
-      expect(statusBefore.key.ttlRemaining).toBeGreaterThan(100);
-
-      await new Promise(resolve => setTimeout(resolve, 150));
-
-      const statusAfter = getStatus();
-      expect(statusAfter.key.ttlRemaining).toBeLessThan(100);
-    });
-  });
-});
-
-describe('debounce', () => {
-  test('should delay function execution', async () => {
-    let called = false;
-    const fn = () => { called = true; };
-    const debounced = debounce(fn, 50);
-
-    debounced();
-
-    expect(called).toBe(false);
-
-    await new Promise(resolve => setTimeout(resolve, 60));
-
-    expect(called).toBe(true);
-  });
-
-  test('should only call function once for rapid calls', async () => {
-    let callCount = 0;
-    const fn = () => { callCount++; };
-    const debounced = debounce(fn, 50);
-
-    debounced();
-    debounced();
-    debounced();
-
-    await new Promise(resolve => setTimeout(resolve, 60));
-
-    expect(callCount).toBe(1);
-  });
-
-  test('should pass arguments to debounced function', async () => {
-    let receivedArgs = null;
-    const fn = (...args) => { receivedArgs = args; };
-    const debounced = debounce(fn, 50);
-
-    debounced('arg1', 'arg2');
-
-    await new Promise(resolve => setTimeout(resolve, 60));
-
-    expect(receivedArgs).toEqual(['arg1', 'arg2']);
-  });
-
-  test('should reset delay on each call', async () => {
-    let callCount = 0;
-    const fn = () => { callCount++; };
-    const debounced = debounce(fn, 50);
-
-    debounced();
-    await new Promise(resolve => setTimeout(resolve, 30));
-    debounced();
-    await new Promise(resolve => setTimeout(resolve, 30));
-
-    expect(callCount).toBe(0);
-
-    await new Promise(resolve => setTimeout(resolve, 30));
-
-    expect(callCount).toBe(1);
-  });
-});
-
-describe('throttle', () => {
-  test('should execute function immediately on first call', () => {
-    let called = false;
-    const fn = () => { called = true; };
-    const throttled = throttle(fn, 100);
-
-    throttled();
-
-    expect(called).toBe(true);
-  });
-
-  test('should not execute again within limit period', async () => {
-    let callCount = 0;
-    const fn = () => { callCount++; };
-    const throttled = throttle(fn, 100);
-
-    throttled();
-    throttled();
-    throttled();
-
-    expect(callCount).toBe(1);
-  });
-
-  test('should execute again after limit period', async () => {
-    let callCount = 0;
-    const fn = () => { callCount++; };
-    const throttled = throttle(fn, 50);
-
-    throttled();
-    await new Promise(resolve => setTimeout(resolve, 60));
-    throttled();
-
-    expect(callCount).toBe(2);
-  });
-
-  test('should pass arguments to throttled function', () => {
-    let receivedArgs = null;
-    const fn = (...args) => { receivedArgs = args; };
-    const throttled = throttle(fn, 100);
-
-    throttled('arg1', 'arg2');
-
-    expect(receivedArgs).toEqual(['arg1', 'arg2']);
-  });
-
-  test('should execute throttled call after limit period expires', async () => {
-    let callCount = 0;
-    const fn = () => { callCount++; };
-    const throttled = throttle(fn, 50);
-
-    throttled(); // executed immediately
-    throttled(); // within limit - ignored
-
-    await new Promise(resolve => setTimeout(resolve, 60));
-
-    // After limit period expires, throttled function executes again
-    expect(callCount).toBe(2);
-  });
-});

package/tests/cli.test.js

@@ -1,351 +0,0 @@
-/**
- * CLI Module Tests
- * Tests for CLI argument parsing, help output, and command handling
- */
-
-import { jest } from '@jest/globals';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync, existsSync } from 'fs';
-import { tmpdir } from 'os';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Store original argv and env
-const originalArgv = process.argv;
-const originalEnv = process.env;
-
-describe('CLI Module Tests', () => {
-  let tempDir;
-
-  beforeEach(async () => {
-    // Reset modules before each test
-    jest.resetModules();
-
-    // Create temp directory for file-based tests
-    tempDir = mkdtempSync(join(tmpdir(), 'claw-cli-test-'));
-
-    // Reset process.argv to default
-    process.argv = ['node', 'clawdash'];
-  });
-
-  afterEach(() => {
-    // Restore original values
-    process.argv = originalArgv;
-    process.env = originalEnv;
-
-    // Clean up temp directory
-    if (existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-
-    // Clear module cache
-    jest.clearAllMocks();
-  });
-
-  describe('Argument Parsing', () => {
-    it('should parse default options when no arguments provided', async () => {
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.help).toBe(false);
-      expect(options.version).toBe(false);
-      expect(options.debug).toBe(false);
-      expect(options.web).toBe(false);
-      expect(options.watch).toBe(false);
-      expect(options.command).toBeNull();
-    });
-
-    it('should parse --help flag', async () => {
-      process.argv = ['node', 'clawdash', '--help'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.help).toBe(true);
-    });
-
-    it('should parse -h shorthand', async () => {
-      process.argv = ['node', 'clawdash', '-h'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.help).toBe(true);
-    });
-
-    it('should parse --version flag', async () => {
-      process.argv = ['node', 'clawdash', '--version'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.version).toBe(true);
-    });
-
-    it('should parse -v shorthand', async () => {
-      process.argv = ['node', 'clawdash', '-v'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.version).toBe(true);
-    });
-
-    it('should parse --debug flag', async () => {
-      process.argv = ['node', 'clawdash', '--debug'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.debug).toBe(true);
-    });
-
-    it('should parse -d shorthand', async () => {
-      process.argv = ['node', 'clawdash', '-d'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.debug).toBe(true);
-    });
-
-    it('should parse --web flag', async () => {
-      process.argv = ['node', 'clawdash', '--web'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.web).toBe(true);
-    });
-
-    it('should parse -w shorthand', async () => {
-      process.argv = ['node', 'clawdash', '-w'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.web).toBe(true);
-    });
-
-    it('should parse --web-port with valid port', async () => {
-      process.argv = ['node', 'clawdash', '--web-port', '8080'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.web).toBe(true);
-      expect(options.webPort).toBe(8080);
-    });
-
-    it('should parse -p shorthand with valid port', async () => {
-      process.argv = ['node', 'clawdash', '-p', '9000'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.web).toBe(true);
-      expect(options.webPort).toBe(9000);
-    });
-
-    it('should ignore invalid port numbers', async () => {
-      process.argv = ['node', 'clawdash', '--web-port', 'invalid'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.web).toBe(true);
-      // Should use default port
-      expect(options.webPort).toBeGreaterThan(0);
-    });
-
-    it('should ignore out-of-range port numbers', async () => {
-      process.argv = ['node', 'clawdash', '--web-port', '99999'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.web).toBe(true);
-      // Should use default port
-      expect(options.webPort).toBeGreaterThan(0);
-    });
-
-    it('should parse --web-host', async () => {
-      process.argv = ['node', 'clawdash', '--web-host', '0.0.0.0'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.web).toBe(true);
-      expect(options.webHost).toBe('0.0.0.0');
-    });
-
-    it('should parse --watch flag', async () => {
-      process.argv = ['node', 'clawdash', '--watch'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.watch).toBe(true);
-    });
-
-    it('should parse -W shorthand', async () => {
-      process.argv = ['node', 'clawdash', '-W'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.watch).toBe(true);
-    });
-
-    it('should parse --watch-plugins flag', async () => {
-      process.argv = ['node', 'clawdash', '--watch-plugins'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.watchPlugins).toBe(true);
-    });
-
-    it('should parse multiple flags', async () => {
-      process.argv = ['node', 'clawdash', '--debug', '--web', '--watch'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.debug).toBe(true);
-      expect(options.web).toBe(true);
-      expect(options.watch).toBe(true);
-    });
-
-    it('should parse create-plugin command', async () => {
-      process.argv = ['node', 'clawdash', 'create-plugin', 'my-widget'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.command).toBe('create-plugin');
-      expect(options.commandArgs).toEqual(['my-widget']);
-    });
-
-    it('should parse validate-plugin command', async () => {
-      process.argv = ['node', 'clawdash', 'validate-plugin', './my-plugin'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.command).toBe('validate-plugin');
-      expect(options.commandArgs).toEqual(['./my-plugin']);
-    });
-
-    it('should parse validate-config command', async () => {
-      process.argv = ['node', 'clawdash', 'validate-config', './config.json'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.command).toBe('validate-config');
-      expect(options.commandArgs).toEqual(['./config.json']);
-    });
-
-    it('should handle command with multiple args', async () => {
-      process.argv = ['node', 'clawdash', 'create-plugin', 'my-widget', '--template', 'basic'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.command).toBe('create-plugin');
-      expect(options.commandArgs).toEqual(['my-widget', '--template', 'basic']);
-    });
-
-    it('should handle unknown flags gracefully', async () => {
-      process.argv = ['node', 'clawdash', '--unknown-flag'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      // Should not throw
-      const options = parseCliArgs();
-
-      expect(options).toBeDefined();
-      expect(options.help).toBe(false);
-    });
-
-    it('should handle empty arguments', async () => {
-      process.argv = ['node', 'clawdash'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      expect(options.command).toBeNull();
-      expect(options.help).toBe(false);
-      expect(options.version).toBe(false);
-    });
-
-    it('should handle flags after command', async () => {
-      process.argv = ['node', 'clawdash', 'validate-plugin', './plugin', '--verbose'];
-      const { parseCliArgs } = await import('../src/cli/args.js');
-
-      const options = parseCliArgs();
-
-      // Command parsing should stop after command is detected
-      expect(options.command).toBe('validate-plugin');
-      expect(options.commandArgs).toEqual(['./plugin', '--verbose']);
-    });
-  });
-
-  describe('Help Module', () => {
-    it('should export showHelp function', async () => {
-      const { showHelp } = await import('../src/cli/help.js');
-
-      expect(showHelp).toBeDefined();
-      expect(typeof showHelp).toBe('function');
-    });
-
-    it('should have default export', async () => {
-      const helpModule = await import('../src/cli/help.js');
-
-      expect(helpModule.default).toBeDefined();
-      expect(helpModule.default.showHelp).toBeDefined();
-    });
-  });
-
-  describe('Version Module', () => {
-    it('should export showVersion function', async () => {
-      const { showVersion } = await import('../src/cli/version.js');
-
-      expect(showVersion).toBeDefined();
-      expect(typeof showVersion).toBe('function');
-    });
-
-    it('should have default export', async () => {
-      const versionModule = await import('../src/cli/version.js');
-
-      expect(versionModule.default).toBeDefined();
-      expect(versionModule.default.showVersion).toBeDefined();
-    });
-  });
-
-  describe('Plugin Scaffolding', () => {
-    it('should export createPlugin function', async () => {
-      const { createPlugin } = await import('../src/plugin-scaffold.js');
-
-      expect(createPlugin).toBeDefined();
-      expect(typeof createPlugin).toBe('function');
-    });
-
-    it('should export runScaffoldCli function', async () => {
-      const { runScaffoldCli } = await import('../src/plugin-scaffold.js');
-
-      expect(runScaffoldCli).toBeDefined();
-      expect(typeof runScaffoldCli).toBe('function');
-    });
-
-    it('should export named functions', async () => {
-      const scaffoldModule = await import('../src/plugin-scaffold.js');
-
-      expect(scaffoldModule.createPlugin).toBeDefined();
-      expect(scaffoldModule.runScaffoldCli).toBeDefined();
-    });
-  });
-});