cdp-skill 1.0.0

package/src/tests/ScreenshotCapture.test.js

@@ -0,0 +1,356 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { createScreenshotCapture } from '../capture.js';
+
+describe('ScreenshotCapture', () => {
+  let screenshotCapture;
+  let mockCdp;
+
+  beforeEach(() => {
+    mockCdp = {
+      send: mock.fn()
+    };
+    screenshotCapture = createScreenshotCapture(mockCdp);
+  });
+
+  afterEach(() => {
+    mock.reset();
+  });
+
+  describe('captureViewport', () => {
+    it('should capture viewport screenshot with default options', async () => {
+      const base64Data = Buffer.from('test-image').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      const result = await screenshotCapture.captureViewport();
+
+      assert.strictEqual(mockCdp.send.mock.calls.length, 1);
+      assert.deepStrictEqual(mockCdp.send.mock.calls[0].arguments, [
+        'Page.captureScreenshot',
+        { format: 'png' }
+      ]);
+      assert.ok(Buffer.isBuffer(result));
+      assert.strictEqual(result.toString(), 'test-image');
+    });
+
+    it('should capture viewport screenshot with jpeg format and quality', async () => {
+      const base64Data = Buffer.from('jpeg-image').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      const result = await screenshotCapture.captureViewport({ format: 'jpeg', quality: 80 });
+
+      assert.deepStrictEqual(mockCdp.send.mock.calls[0].arguments, [
+        'Page.captureScreenshot',
+        { format: 'jpeg', quality: 80 }
+      ]);
+      assert.ok(Buffer.isBuffer(result));
+    });
+
+    it('should throw error for quality above 100', async () => {
+      await assert.rejects(
+        () => screenshotCapture.captureViewport({ format: 'jpeg', quality: 150 }),
+        { message: 'Quality must be a number between 0 and 100' }
+      );
+    });
+
+    it('should throw error for quality below 0', async () => {
+      await assert.rejects(
+        () => screenshotCapture.captureViewport({ format: 'jpeg', quality: -10 }),
+        { message: 'Quality must be a number between 0 and 100' }
+      );
+    });
+
+    it('should throw error when quality is set for png format', async () => {
+      await assert.rejects(
+        () => screenshotCapture.captureViewport({ format: 'png', quality: 80 }),
+        { message: 'Quality option is only supported for jpeg and webp formats, not png' }
+      );
+    });
+
+    it('should accept png without quality', async () => {
+      const base64Data = Buffer.from('png-image').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      await screenshotCapture.captureViewport({ format: 'png' });
+
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[1].quality, undefined);
+    });
+  });
+
+  describe('captureFullPage', () => {
+    it('should capture full page screenshot', async () => {
+      const base64Data = Buffer.from('full-page').toString('base64');
+      mockCdp.send.mock.mockImplementation((method) => {
+        if (method === 'Page.getLayoutMetrics') {
+          return Promise.resolve({
+            contentSize: { width: 1200, height: 3000 }
+          });
+        }
+        return Promise.resolve({ data: base64Data });
+      });
+
+      const result = await screenshotCapture.captureFullPage();
+
+      assert.strictEqual(mockCdp.send.mock.calls.length, 2);
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[0], 'Page.getLayoutMetrics');
+      assert.deepStrictEqual(mockCdp.send.mock.calls[1].arguments[1].clip, {
+        x: 0,
+        y: 0,
+        width: 1200,
+        height: 3000,
+        scale: 1
+      });
+      assert.ok(Buffer.isBuffer(result));
+    });
+  });
+
+  describe('captureRegion', () => {
+    it('should capture specific region', async () => {
+      const base64Data = Buffer.from('region').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      const region = { x: 100, y: 200, width: 300, height: 400 };
+      const result = await screenshotCapture.captureRegion(region);
+
+      assert.deepStrictEqual(mockCdp.send.mock.calls[0].arguments[1].clip, {
+        x: 100,
+        y: 200,
+        width: 300,
+        height: 400,
+        scale: 1
+      });
+      assert.ok(Buffer.isBuffer(result));
+    });
+
+    it('should capture region with custom scale', async () => {
+      const base64Data = Buffer.from('region').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      const region = { x: 0, y: 0, width: 100, height: 100 };
+      await screenshotCapture.captureRegion(region, { scale: 2 });
+
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[1].clip.scale, 2);
+    });
+  });
+
+  describe('captureElement', () => {
+    it('should capture element with bounding box', async () => {
+      const base64Data = Buffer.from('element').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      const boundingBox = { x: 50, y: 100, width: 200, height: 150 };
+      await screenshotCapture.captureElement(boundingBox);
+
+      assert.deepStrictEqual(mockCdp.send.mock.calls[0].arguments[1].clip, {
+        x: 50,
+        y: 100,
+        width: 200,
+        height: 150,
+        scale: 1
+      });
+    });
+
+    it('should capture element with padding', async () => {
+      const base64Data = Buffer.from('element').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      const boundingBox = { x: 50, y: 100, width: 200, height: 150 };
+      await screenshotCapture.captureElement(boundingBox, { padding: 10 });
+
+      assert.deepStrictEqual(mockCdp.send.mock.calls[0].arguments[1].clip, {
+        x: 40,
+        y: 90,
+        width: 220,
+        height: 170,
+        scale: 1
+      });
+    });
+
+    it('should not allow negative coordinates with padding', async () => {
+      const base64Data = Buffer.from('element').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      const boundingBox = { x: 5, y: 5, width: 100, height: 100 };
+      await screenshotCapture.captureElement(boundingBox, { padding: 10 });
+
+      const clip = mockCdp.send.mock.calls[0].arguments[1].clip;
+      assert.strictEqual(clip.x, 0);
+      assert.strictEqual(clip.y, 0);
+    });
+  });
+
+  describe('format validation', () => {
+    it('should accept png format', async () => {
+      const base64Data = Buffer.from('png').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      await screenshotCapture.captureViewport({ format: 'png' });
+
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[1].format, 'png');
+    });
+
+    it('should accept jpeg format', async () => {
+      const base64Data = Buffer.from('jpeg').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      await screenshotCapture.captureViewport({ format: 'jpeg' });
+
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[1].format, 'jpeg');
+    });
+
+    it('should accept webp format', async () => {
+      const base64Data = Buffer.from('webp').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      await screenshotCapture.captureViewport({ format: 'webp' });
+
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[1].format, 'webp');
+    });
+
+    it('should throw error for invalid format', async () => {
+      await assert.rejects(
+        () => screenshotCapture.captureViewport({ format: 'gif' }),
+        { message: 'Invalid screenshot format "gif". Valid formats are: png, jpeg, webp' }
+      );
+    });
+
+    it('should throw error for invalid format in captureFullPage', async () => {
+      await assert.rejects(
+        () => screenshotCapture.captureFullPage({ format: 'bmp' }),
+        { message: 'Invalid screenshot format "bmp". Valid formats are: png, jpeg, webp' }
+      );
+    });
+
+    it('should throw error for invalid format in captureRegion', async () => {
+      await assert.rejects(
+        () => screenshotCapture.captureRegion({ x: 0, y: 0, width: 100, height: 100 }, { format: 'tiff' }),
+        { message: 'Invalid screenshot format "tiff". Valid formats are: png, jpeg, webp' }
+      );
+    });
+
+    it('should throw error for invalid format in captureElement', async () => {
+      await assert.rejects(
+        () => screenshotCapture.captureElement({ x: 0, y: 0, width: 100, height: 100 }, { format: 'svg' }),
+        { message: 'Invalid screenshot format "svg". Valid formats are: png, jpeg, webp' }
+      );
+    });
+
+    it('should accept quality for webp format', async () => {
+      const base64Data = Buffer.from('webp').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      await screenshotCapture.captureViewport({ format: 'webp', quality: 75 });
+
+      assert.deepStrictEqual(mockCdp.send.mock.calls[0].arguments, [
+        'Page.captureScreenshot',
+        { format: 'webp', quality: 75 }
+      ]);
+    });
+
+    it('should throw error for non-numeric quality', async () => {
+      await assert.rejects(
+        () => screenshotCapture.captureViewport({ format: 'jpeg', quality: 'high' }),
+        { message: 'Quality must be a number between 0 and 100' }
+      );
+    });
+
+    it('should accept quality of exactly 0', async () => {
+      const base64Data = Buffer.from('jpeg').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      await screenshotCapture.captureViewport({ format: 'jpeg', quality: 0 });
+
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[1].quality, 0);
+    });
+
+    it('should accept quality of exactly 100', async () => {
+      const base64Data = Buffer.from('jpeg').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      await screenshotCapture.captureViewport({ format: 'jpeg', quality: 100 });
+
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[1].quality, 100);
+    });
+
+    it('should validate format before making CDP call in captureFullPage', async () => {
+      // Ensure validation happens before getLayoutMetrics is called
+      await assert.rejects(
+        () => screenshotCapture.captureFullPage({ format: 'invalid' }),
+        /Invalid screenshot format/
+      );
+
+      // Verify no CDP calls were made
+      assert.strictEqual(mockCdp.send.mock.calls.length, 0);
+    });
+  });
+
+  describe('saveToFile', () => {
+    it('should return absolute path for saved file', async () => {
+      // Note: We can't easily mock fs/promises in ESM, so we just test the path logic
+      const buffer = Buffer.from('test-data');
+      const path = '/tmp/screenshot-test-' + Date.now() + '.png';
+
+      // This will actually write the file, but tests the functionality
+      const result = await screenshotCapture.saveToFile(buffer, path);
+
+      assert.ok(result.endsWith('.png'));
+      assert.ok(result.includes('screenshot-test-'));
+
+      // Cleanup
+      const fs = await import('fs/promises');
+      try {
+        await fs.unlink(result);
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    });
+  });
+
+  describe('captureToFile', () => {
+    it('should capture viewport and save to file', async () => {
+      const base64Data = Buffer.from('viewport').toString('base64');
+      mockCdp.send.mock.mockImplementation(() => Promise.resolve({ data: base64Data }));
+
+      const path = '/tmp/capture-test-' + Date.now() + '.png';
+      const result = await screenshotCapture.captureToFile(path);
+
+      assert.ok(result.endsWith('.png'));
+      assert.ok(result.includes('capture-test-'));
+
+      // Verify CDP was called correctly
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[0], 'Page.captureScreenshot');
+
+      // Cleanup
+      const fs = await import('fs/promises');
+      try {
+        await fs.unlink(result);
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    });
+
+    it('should capture full page when option is set', async () => {
+      const base64Data = Buffer.from('fullpage').toString('base64');
+      mockCdp.send.mock.mockImplementation((method) => {
+        if (method === 'Page.getLayoutMetrics') {
+          return Promise.resolve({ contentSize: { width: 800, height: 2000 } });
+        }
+        return Promise.resolve({ data: base64Data });
+      });
+
+      const path = '/tmp/fullpage-test-' + Date.now() + '.png';
+      await screenshotCapture.captureToFile(path, { fullPage: true });
+
+      // Should call getLayoutMetrics first for full page
+      assert.strictEqual(mockCdp.send.mock.calls[0].arguments[0], 'Page.getLayoutMetrics');
+
+      // Cleanup
+      const fs = await import('fs/promises');
+      try {
+        await fs.unlink(path);
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    });
+  });
+});

package/src/tests/SessionRegistry.test.js

@@ -0,0 +1,257 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { createSessionRegistry } from '../cdp.js';
+
+/**
+ * Mock CDPConnection for testing
+ */
+function createMockConnection() {
+  const eventListeners = new Map();
+  let sessionCounter = 0;
+
+  return {
+    eventListeners,
+    sentCommands: [],
+
+    on(event, callback) {
+      if (!eventListeners.has(event)) {
+        eventListeners.set(event, new Set());
+      }
+      eventListeners.get(event).add(callback);
+    },
+
+    off(event, callback) {
+      const listeners = eventListeners.get(event);
+      if (listeners) {
+        listeners.delete(callback);
+      }
+    },
+
+    async send(method, params = {}) {
+      this.sentCommands.push({ method, params });
+
+      switch (method) {
+        case 'Target.attachToTarget':
+          sessionCounter++;
+          return { sessionId: `session-${sessionCounter}` };
+        case 'Target.detachFromTarget':
+          return {};
+        default:
+          throw new Error(`Unknown method: ${method}`);
+      }
+    },
+
+    // Helper to emit events for testing
+    emit(event, params) {
+      const listeners = eventListeners.get(event);
+      if (listeners) {
+        for (const callback of listeners) {
+          callback(params);
+        }
+      }
+    }
+  };
+}
+
+describe('SessionRegistry', () => {
+  let mockConnection;
+  let sessionRegistry;
+
+  beforeEach(() => {
+    mockConnection = createMockConnection();
+    sessionRegistry = createSessionRegistry(mockConnection);
+  });
+
+  describe('constructor', () => {
+    it('should create instance and register event listeners', () => {
+      assert.ok(sessionRegistry);
+      assert.ok(mockConnection.eventListeners.has('Target.attachedToTarget'));
+      assert.ok(mockConnection.eventListeners.has('Target.detachedFromTarget'));
+      assert.ok(mockConnection.eventListeners.has('Target.targetDestroyed'));
+    });
+  });
+
+  describe('attach', () => {
+    it('should attach to target and return sessionId', async () => {
+      const sessionId = await sessionRegistry.attach('target-1');
+
+      assert.strictEqual(sessionId, 'session-1');
+
+      const cmd = mockConnection.sentCommands.find(c => c.method === 'Target.attachToTarget');
+      assert.strictEqual(cmd.params.targetId, 'target-1');
+      assert.strictEqual(cmd.params.flatten, true);
+    });
+
+    it('should return existing sessionId if already attached', async () => {
+      const sessionId1 = await sessionRegistry.attach('target-1');
+      const sessionId2 = await sessionRegistry.attach('target-1');
+
+      assert.strictEqual(sessionId1, sessionId2);
+
+      const cmds = mockConnection.sentCommands.filter(c => c.method === 'Target.attachToTarget');
+      assert.strictEqual(cmds.length, 1);
+    });
+
+    it('should track session and target mappings', async () => {
+      await sessionRegistry.attach('target-1');
+
+      assert.strictEqual(sessionRegistry.getSessionForTarget('target-1'), 'session-1');
+      assert.strictEqual(sessionRegistry.getTargetForSession('session-1'), 'target-1');
+    });
+  });
+
+  describe('detach', () => {
+    it('should detach from session', async () => {
+      const sessionId = await sessionRegistry.attach('target-1');
+      await sessionRegistry.detach(sessionId);
+
+      const cmd = mockConnection.sentCommands.find(c => c.method === 'Target.detachFromTarget');
+      assert.strictEqual(cmd.params.sessionId, sessionId);
+    });
+
+    it('should clear session and target mappings', async () => {
+      const sessionId = await sessionRegistry.attach('target-1');
+      await sessionRegistry.detach(sessionId);
+
+      assert.strictEqual(sessionRegistry.getSessionForTarget('target-1'), undefined);
+      assert.strictEqual(sessionRegistry.getTargetForSession(sessionId), undefined);
+    });
+
+    it('should do nothing for unknown session', async () => {
+      await sessionRegistry.detach('unknown-session');
+
+      const cmds = mockConnection.sentCommands.filter(c => c.method === 'Target.detachFromTarget');
+      assert.strictEqual(cmds.length, 0);
+    });
+  });
+
+  describe('detachByTarget', () => {
+    it('should detach by targetId', async () => {
+      await sessionRegistry.attach('target-1');
+      await sessionRegistry.detachByTarget('target-1');
+
+      assert.strictEqual(sessionRegistry.isAttached('target-1'), false);
+    });
+
+    it('should do nothing for unknown target', async () => {
+      await sessionRegistry.detachByTarget('unknown-target');
+
+      const cmds = mockConnection.sentCommands.filter(c => c.method === 'Target.detachFromTarget');
+      assert.strictEqual(cmds.length, 0);
+    });
+  });
+
+  describe('isAttached', () => {
+    it('should return true for attached target', async () => {
+      await sessionRegistry.attach('target-1');
+
+      assert.strictEqual(sessionRegistry.isAttached('target-1'), true);
+    });
+
+    it('should return false for unattached target', () => {
+      assert.strictEqual(sessionRegistry.isAttached('target-1'), false);
+    });
+  });
+
+  describe('getAllSessions', () => {
+    it('should return all active sessions', async () => {
+      await sessionRegistry.attach('target-1');
+      await sessionRegistry.attach('target-2');
+
+      const sessions = sessionRegistry.getAllSessions();
+
+      assert.strictEqual(sessions.length, 2);
+      assert.ok(sessions.some(s => s.targetId === 'target-1'));
+      assert.ok(sessions.some(s => s.targetId === 'target-2'));
+    });
+
+    it('should return empty array when no sessions', () => {
+      const sessions = sessionRegistry.getAllSessions();
+      assert.strictEqual(sessions.length, 0);
+    });
+  });
+
+  describe('detachAll', () => {
+    it('should detach all sessions', async () => {
+      await sessionRegistry.attach('target-1');
+      await sessionRegistry.attach('target-2');
+
+      await sessionRegistry.detachAll();
+
+      assert.strictEqual(sessionRegistry.getAllSessions().length, 0);
+
+      const cmds = mockConnection.sentCommands.filter(c => c.method === 'Target.detachFromTarget');
+      assert.strictEqual(cmds.length, 2);
+    });
+  });
+
+  describe('event handling', () => {
+    it('should handle attachedToTarget event', () => {
+      mockConnection.emit('Target.attachedToTarget', {
+        sessionId: 'external-session',
+        targetInfo: { targetId: 'external-target' }
+      });
+
+      assert.strictEqual(sessionRegistry.getSessionForTarget('external-target'), 'external-session');
+      assert.strictEqual(sessionRegistry.getTargetForSession('external-session'), 'external-target');
+    });
+
+    it('should handle detachedFromTarget event', async () => {
+      const sessionId = await sessionRegistry.attach('target-1');
+
+      mockConnection.emit('Target.detachedFromTarget', { sessionId });
+
+      assert.strictEqual(sessionRegistry.isAttached('target-1'), false);
+    });
+
+    it('should handle targetDestroyed event (external tab close)', async () => {
+      await sessionRegistry.attach('target-1');
+      assert.strictEqual(sessionRegistry.isAttached('target-1'), true);
+
+      // Simulate Chrome closing the tab externally
+      mockConnection.emit('Target.targetDestroyed', { targetId: 'target-1' });
+
+      assert.strictEqual(sessionRegistry.isAttached('target-1'), false);
+      assert.strictEqual(sessionRegistry.getSessionForTarget('target-1'), undefined);
+    });
+
+    it('should ignore targetDestroyed for unknown targets', () => {
+      // Should not throw
+      mockConnection.emit('Target.targetDestroyed', { targetId: 'unknown-target' });
+    });
+  });
+
+  describe('concurrent attach handling', () => {
+    it('should return same session for concurrent attach calls to same target', async () => {
+      // Start two attach calls concurrently
+      const [sessionId1, sessionId2] = await Promise.all([
+        sessionRegistry.attach('target-1'),
+        sessionRegistry.attach('target-1')
+      ]);
+
+      assert.strictEqual(sessionId1, sessionId2);
+
+      // Should only have sent one attach command
+      const cmds = mockConnection.sentCommands.filter(c => c.method === 'Target.attachToTarget');
+      assert.strictEqual(cmds.length, 1);
+    });
+  });
+
+  describe('cleanup', () => {
+    it('should detach all sessions and remove event listeners', async () => {
+      await sessionRegistry.attach('target-1');
+      await sessionRegistry.attach('target-2');
+
+      await sessionRegistry.cleanup();
+
+      assert.strictEqual(sessionRegistry.getAllSessions().length, 0);
+
+      // Event listeners should be removed
+      const attachedListeners = mockConnection.eventListeners.get('Target.attachedToTarget');
+      assert.strictEqual(attachedListeners?.size || 0, 0);
+
+      const destroyedListeners = mockConnection.eventListeners.get('Target.targetDestroyed');
+      assert.strictEqual(destroyedListeners?.size || 0, 0);
+    });
+  });
+});