claw-dashboard 1.8.4 → 2.0.0

package/tests/cache.test.js

@@ -0,0 +1,317 @@
+/**
+ * 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

@@ -0,0 +1,351 @@
+/**
+ * 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();
+    });
+  });
+});