cdp-skill 1.0.0

package/src/tests/ChromeDiscovery.test.js

@@ -0,0 +1,181 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { createDiscovery } from '../cdp.js';
+
+describe('ChromeDiscovery', () => {
+  let originalFetch;
+  let mockFetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    mockFetch = mock.fn();
+    globalThis.fetch = mockFetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  describe('createDiscovery', () => {
+    it('should create discovery with default host and port', () => {
+      const discovery = createDiscovery();
+      assert.ok(discovery);
+      assert.ok(typeof discovery.getVersion === 'function');
+    });
+
+    it('should accept custom host and port', () => {
+      const discovery = createDiscovery('192.168.1.100', 9333);
+      assert.ok(discovery);
+    });
+  });
+
+  describe('getVersion', () => {
+    it('should return browser version info', async () => {
+      const mockResponse = {
+        Browser: 'Chrome/120.0.0.0',
+        'Protocol-Version': '1.3',
+        webSocketDebuggerUrl: 'ws://localhost:9222/devtools/browser/abc'
+      };
+
+      mockFetch.mock.mockImplementation(() => Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(mockResponse)
+      }));
+
+      const discovery = createDiscovery();
+      const result = await discovery.getVersion();
+
+      assert.strictEqual(result.browser, 'Chrome/120.0.0.0');
+      assert.strictEqual(result.protocolVersion, '1.3');
+      assert.strictEqual(result.webSocketDebuggerUrl, 'ws://localhost:9222/devtools/browser/abc');
+    });
+
+    it('should throw when Chrome not reachable', async () => {
+      mockFetch.mock.mockImplementation(() => Promise.resolve({
+        ok: false,
+        status: 404
+      }));
+
+      const discovery = createDiscovery();
+
+      await assert.rejects(
+        () => discovery.getVersion(),
+        /Chrome not reachable/
+      );
+    });
+  });
+
+  describe('getTargets', () => {
+    it('should return all targets', async () => {
+      const mockTargets = [
+        { id: '1', type: 'page', title: 'Tab 1', url: 'https://example.com' },
+        { id: '2', type: 'service_worker', title: 'SW', url: 'https://example.com/sw.js' }
+      ];
+
+      mockFetch.mock.mockImplementation(() => Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(mockTargets)
+      }));
+
+      const discovery = createDiscovery();
+      const result = await discovery.getTargets();
+
+      assert.strictEqual(result.length, 2);
+      assert.strictEqual(result[0].id, '1');
+      assert.strictEqual(result[1].type, 'service_worker');
+    });
+
+    it('should throw on failure', async () => {
+      mockFetch.mock.mockImplementation(() => Promise.resolve({
+        ok: false,
+        status: 500
+      }));
+
+      const discovery = createDiscovery();
+
+      await assert.rejects(
+        () => discovery.getTargets(),
+        /Failed to get targets: 500/
+      );
+    });
+  });
+
+  describe('getPages', () => {
+    it('should return only page targets', async () => {
+      const mockTargets = [
+        { id: '1', type: 'page', title: 'Tab 1', url: 'https://example.com' },
+        { id: '2', type: 'service_worker', title: 'SW', url: 'https://example.com/sw.js' },
+        { id: '3', type: 'page', title: 'Tab 2', url: 'https://test.com' }
+      ];
+
+      mockFetch.mock.mockImplementation(() => Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(mockTargets)
+      }));
+
+      const discovery = createDiscovery();
+      const result = await discovery.getPages();
+
+      assert.strictEqual(result.length, 2);
+      assert.ok(result.every(t => t.type === 'page'));
+    });
+  });
+
+  describe('findPageByUrl', () => {
+    const mockTargets = [
+      { id: '1', type: 'page', title: 'Example', url: 'https://example.com/path' },
+      { id: '2', type: 'page', title: 'Test', url: 'https://test.com' }
+    ];
+
+    beforeEach(() => {
+      mockFetch.mock.mockImplementation(() => Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(mockTargets)
+      }));
+    });
+
+    it('should find page by string pattern', async () => {
+      const discovery = createDiscovery();
+      const result = await discovery.findPageByUrl('example.com');
+
+      assert.strictEqual(result.id, '1');
+    });
+
+    it('should find page by regex pattern', async () => {
+      const discovery = createDiscovery();
+      const result = await discovery.findPageByUrl(/test\.com$/);
+
+      assert.strictEqual(result.id, '2');
+    });
+
+    it('should return null when no match', async () => {
+      const discovery = createDiscovery();
+      const result = await discovery.findPageByUrl('nonexistent.com');
+
+      assert.strictEqual(result, null);
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return true when Chrome is running', async () => {
+      mockFetch.mock.mockImplementation(() => Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ Browser: 'Chrome' })
+      }));
+
+      const discovery = createDiscovery();
+      const result = await discovery.isAvailable();
+
+      assert.strictEqual(result, true);
+    });
+
+    it('should return false when Chrome is not running', async () => {
+      mockFetch.mock.mockImplementation(() => Promise.reject(new Error('Connection refused')));
+
+      const discovery = createDiscovery();
+      const result = await discovery.isAvailable();
+
+      assert.strictEqual(result, false);
+    });
+  });
+});

package/src/tests/ConsoleCapture.test.js

@@ -0,0 +1,302 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { createConsoleCapture } from '../capture.js';
+
+describe('ConsoleCapture', () => {
+  let consoleCapture;
+  let mockCdp;
+  let eventHandlers;
+
+  beforeEach(() => {
+    eventHandlers = {};
+    mockCdp = {
+      send: mock.fn(() => Promise.resolve()),
+      on: mock.fn((event, handler) => {
+        eventHandlers[event] = handler;
+      }),
+      off: mock.fn((event, handler) => {
+        if (eventHandlers[event] === handler) {
+          delete eventHandlers[event];
+        }
+      })
+    };
+    consoleCapture = createConsoleCapture(mockCdp);
+  });
+
+  afterEach(() => {
+    mock.reset();
+  });
+
+  describe('factory function', () => {
+    it('should create instance via factory function', () => {
+      const capture = createConsoleCapture(mockCdp);
+      assert.ok(capture);
+      assert.strictEqual(typeof capture.startCapture, 'function');
+      assert.strictEqual(typeof capture.stopCapture, 'function');
+      assert.strictEqual(typeof capture.getMessages, 'function');
+    });
+  });
+
+  describe('startCapture', () => {
+    it('should enable Runtime domain only (not Console)', async () => {
+      await consoleCapture.startCapture();
+
+      const sendCalls = mockCdp.send.mock.calls.map(c => c.arguments[0]);
+      assert.ok(sendCalls.includes('Runtime.enable'));
+      assert.ok(!sendCalls.includes('Console.enable'), 'Console.enable should not be called');
+    });
+
+    it('should register only Runtime event handlers', async () => {
+      await consoleCapture.startCapture();
+
+      assert.strictEqual(mockCdp.on.mock.calls.length, 2);
+      assert.ok(!eventHandlers['Console.messageAdded'], 'Console.messageAdded should not be registered');
+      assert.ok(eventHandlers['Runtime.consoleAPICalled']);
+      assert.ok(eventHandlers['Runtime.exceptionThrown']);
+    });
+
+    it('should not start capturing twice', async () => {
+      await consoleCapture.startCapture();
+      await consoleCapture.startCapture();
+
+      assert.strictEqual(mockCdp.send.mock.calls.length, 1);
+    });
+  });
+
+  describe('stopCapture', () => {
+    it('should disable Runtime domain only (not Console)', async () => {
+      await consoleCapture.startCapture();
+      await consoleCapture.stopCapture();
+
+      const sendCalls = mockCdp.send.mock.calls.map(c => c.arguments[0]);
+      assert.ok(sendCalls.includes('Runtime.disable'));
+      assert.ok(!sendCalls.includes('Console.disable'), 'Console.disable should not be called');
+    });
+
+    it('should unregister event handlers', async () => {
+      await consoleCapture.startCapture();
+      await consoleCapture.stopCapture();
+
+      assert.strictEqual(mockCdp.off.mock.calls.length, 2);
+    });
+
+    it('should do nothing if not capturing', async () => {
+      await consoleCapture.stopCapture();
+
+      assert.strictEqual(mockCdp.send.mock.calls.length, 0);
+    });
+  });
+
+  describe('message capture', () => {
+    it('should capture Runtime.consoleAPICalled events with type "console"', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({
+        type: 'log',
+        args: [{ value: 'Hello' }, { value: 'World' }],
+        timestamp: 12345
+      });
+
+      const messages = consoleCapture.getMessages();
+      assert.strictEqual(messages.length, 1);
+      assert.strictEqual(messages[0].type, 'console');
+      assert.strictEqual(messages[0].level, 'log');
+      assert.strictEqual(messages[0].text, 'Hello World');
+    });
+
+    it('should not produce duplicate messages (only one per console call)', async () => {
+      await consoleCapture.startCapture();
+
+      // Only consoleAPICalled should be registered - no Console.messageAdded
+      eventHandlers['Runtime.consoleAPICalled']({
+        type: 'log',
+        args: [{ value: 'Test message' }],
+        timestamp: 12345
+      });
+
+      const messages = consoleCapture.getMessages();
+      assert.strictEqual(messages.length, 1, 'Should have exactly one message per console call');
+    });
+
+    it('should capture Runtime.exceptionThrown events', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.exceptionThrown']({
+        timestamp: 12345,
+        exceptionDetails: {
+          text: 'Uncaught ReferenceError: foo is not defined',
+          url: 'http://test.com/app.js',
+          lineNumber: 100,
+          columnNumber: 5,
+          exception: {
+            description: 'ReferenceError: foo is not defined'
+          }
+        }
+      });
+
+      const messages = consoleCapture.getMessages();
+      assert.strictEqual(messages.length, 1);
+      assert.strictEqual(messages[0].type, 'exception');
+      assert.strictEqual(messages[0].level, 'error');
+    });
+  });
+
+  describe('getMessagesByLevel', () => {
+    it('should filter messages by single level', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'log', args: [{ value: 'Log' }], timestamp: 1 });
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'error', args: [{ value: 'Error' }], timestamp: 2 });
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'warn', args: [{ value: 'Warning' }], timestamp: 3 });
+
+      const errors = consoleCapture.getMessagesByLevel('error');
+      assert.strictEqual(errors.length, 1);
+      assert.strictEqual(errors[0].text, 'Error');
+    });
+
+    it('should filter messages by multiple levels', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'log', args: [{ value: 'Log' }], timestamp: 1 });
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'error', args: [{ value: 'Error' }], timestamp: 2 });
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'warn', args: [{ value: 'Warning' }], timestamp: 3 });
+
+      const filtered = consoleCapture.getMessagesByLevel(['error', 'warning']);
+      assert.strictEqual(filtered.length, 2);
+    });
+  });
+
+  describe('getErrors', () => {
+    it('should return only errors and exceptions', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'log', args: [{ value: 'Log' }], timestamp: 1 });
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'error', args: [{ value: 'Error' }], timestamp: 2 });
+      eventHandlers['Runtime.exceptionThrown']({
+        timestamp: 3,
+        exceptionDetails: { text: 'Exception' }
+      });
+
+      const errors = consoleCapture.getErrors();
+      assert.strictEqual(errors.length, 2);
+    });
+  });
+
+  describe('getWarnings', () => {
+    it('should return only warnings', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'warn', args: [{ value: 'Warning 1' }], timestamp: 1 });
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'log', args: [{ value: 'Log' }], timestamp: 2 });
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'warning', args: [{ value: 'Warning 2' }], timestamp: 3 });
+
+      const warnings = consoleCapture.getWarnings();
+      assert.strictEqual(warnings.length, 2);
+    });
+  });
+
+  describe('hasErrors', () => {
+    it('should return false when no errors', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'log', args: [{ value: 'Log' }], timestamp: 1 });
+
+      assert.strictEqual(consoleCapture.hasErrors(), false);
+    });
+
+    it('should return true when errors exist', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'error', args: [{ value: 'Error' }], timestamp: 1 });
+
+      assert.strictEqual(consoleCapture.hasErrors(), true);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all messages', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({ type: 'log', args: [{ value: 'Log' }], timestamp: 1 });
+      assert.strictEqual(consoleCapture.getMessages().length, 1);
+
+      consoleCapture.clear();
+      assert.strictEqual(consoleCapture.getMessages().length, 0);
+    });
+  });
+
+  describe('clearBrowserConsole', () => {
+    it('should send Console.clearMessages', async () => {
+      await consoleCapture.clearBrowserConsole();
+
+      assert.strictEqual(mockCdp.send.mock.calls.length, 1);
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[0], 'Console.clearMessages');
+    });
+  });
+
+  describe('arg formatting', () => {
+    it('should format different arg types', async () => {
+      await consoleCapture.startCapture();
+
+      eventHandlers['Runtime.consoleAPICalled']({
+        type: 'log',
+        args: [
+          { value: 'string' },
+          { description: '[Object]' },
+          { unserializableValue: 'Infinity' },
+          { type: 'function' }
+        ],
+        timestamp: 1
+      });
+
+      const messages = consoleCapture.getMessages();
+      assert.strictEqual(messages[0].text, 'string [Object] Infinity [function]');
+    });
+  });
+
+  describe('console type mapping', () => {
+    it('should map console types to levels', async () => {
+      await consoleCapture.startCapture();
+
+      const types = ['log', 'debug', 'info', 'error', 'warn', 'dir', 'table', 'trace', 'assert'];
+
+      for (const type of types) {
+        eventHandlers['Runtime.consoleAPICalled']({
+          type,
+          args: [{ value: type }],
+          timestamp: Date.now()
+        });
+      }
+
+      const messages = consoleCapture.getMessages();
+      // log: log, dir, table, trace = 4
+      assert.strictEqual(messages.filter(m => m.level === 'log').length, 4);
+      assert.strictEqual(messages.filter(m => m.level === 'debug').length, 1);
+      assert.strictEqual(messages.filter(m => m.level === 'info').length, 1);
+      // error: error, assert = 2
+      assert.strictEqual(messages.filter(m => m.level === 'error').length, 2);
+      // warning: warn = 1
+      assert.strictEqual(messages.filter(m => m.level === 'warning').length, 1);
+    });
+  });
+
+  describe('maxMessages limit', () => {
+    it('should respect maxMessages option', async () => {
+      const limitedCapture = createConsoleCapture(mockCdp, { maxMessages: 3 });
+      await limitedCapture.startCapture();
+
+      for (let i = 0; i < 5; i++) {
+        eventHandlers['Runtime.consoleAPICalled']({
+          type: 'log',
+          args: [{ value: `Message ${i}` }],
+          timestamp: i
+        });
+      }
+
+      const messages = limitedCapture.getMessages();
+      assert.strictEqual(messages.length, 3);
+      assert.strictEqual(messages[0].text, 'Message 2');
+      assert.strictEqual(messages[2].text, 'Message 4');
+    });
+  });
+});