test: add test coverage for Mutex, DevToolsConnectionAdapter, and WaitForHelper

tests/DevToolsConnectionAdapter.test.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
+import sinon from 'sinon';
+
+import {DevToolsConnectionAdapter} from '../src/DevToolsConnectionAdapter.js';
+import {type ConnectionTransport} from '../src/third_party/index.js';
+
+class MockTransport implements ConnectionTransport {
+  onmessage: ((message: string) => void) | undefined;
+  onclose: (() => void) | undefined;
+
+  send(message: string): void {}
+  close(): void {}
+}
+
+describe('DevToolsConnectionAdapter', () => {
+  it('should pass messages from transport to onMessage', () => {
+    const transport = new MockTransport();
+    const adapter = new DevToolsConnectionAdapter(transport);
+    const onMessage = sinon.spy();
+
+    adapter.setOnMessage(onMessage);
+    transport.onmessage?.('test message');
+
+    assert.ok(onMessage.calledOnceWith('test message'));
+  });
+
+  it('should call onDisconnect when transport closes', () => {
+    const transport = new MockTransport();
+    const adapter = new DevToolsConnectionAdapter(transport);
+    const onDisconnect = sinon.spy();
+
+    adapter.setOnDisconnect(onDisconnect);
+    transport.onclose?.();
+
+    assert.ok(onDisconnect.calledOnce);
+  });
+
+  it('should send messages through the transport', () => {
+    const transport = new MockTransport();
+    const spy = sinon.spy(transport, 'send');
+    const adapter = new DevToolsConnectionAdapter(transport);
+
+    adapter.sendRawMessage('test message');
+
+    assert.ok(spy.calledOnceWith('test message'));
+  });
+
+  it('should close the transport on disconnect', async () => {
+    const transport = new MockTransport();
+    const spy = sinon.spy(transport, 'close');
+    const adapter = new DevToolsConnectionAdapter(transport);
+
+    await adapter.disconnect();
+
+    assert.ok(spy.calledOnce);
+  });
+});

tests/Mutex.test.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
+
+import {Mutex} from '../src/Mutex.js';
+
+describe('Mutex', () => {
+  it('should acquire and release the lock', async () => {
+    const mutex = new Mutex();
+    const guard = await mutex.acquire();
+    guard.dispose();
+  });
+
+  it('should prevent multiple acquisitions', async () => {
+    const mutex = new Mutex();
+    await mutex.acquire();
+    let acquired = false;
+    mutex.acquire().then(() => {
+      acquired = true;
+    });
+    // Give the promise a chance to resolve
+    await new Promise(resolve => setTimeout(resolve, 0));
+    assert.strictEqual(acquired, false);
+  });
+
+  it('should allow acquisition after release', async () => {
+    const mutex = new Mutex();
+    const guard1 = await mutex.acquire();
+    guard1.dispose();
+    const guard2 = await mutex.acquire();
+    guard2.dispose();
+  });
+
+  it('should handle FIFO queuing', async () => {
+    const mutex = new Mutex();
+    const order: number[] = [];
+    const guard = await mutex.acquire();
+
+    const promise1 = mutex.acquire().then(guard1 => {
+      order.push(1);
+      guard1.dispose();
+    });
+
+    const promise2 = mutex.acquire().then(guard2 => {
+      order.push(2);
+      guard2.dispose();
+    });
+
+    guard.dispose();
+
+    await Promise.all([promise1, promise2]);
+
+    assert.deepStrictEqual(order, [1, 2]);
+  });
+});

tests/WaitForHelper.test.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
+import sinon from 'sinon';
+
+import {WaitForHelper} from '../src/WaitForHelper.js';
+import {type Page, type CdpPage} from '../src/third_party/index.js';
+
+class MockPage {
+  #client = {
+    on() {},
+    off() {},
+  };
+
+  evaluateHandle() {}
+  waitForNavigation() {}
+  _client() {
+    return this.#client;
+  }
+}
+
+describe('WaitForHelper', () => {
+  it('should wait for stable DOM', async () => {
+    const page = new MockPage();
+    const helper = new WaitForHelper(page as unknown as Page, 1, 1);
+    const evaluateHandle = sinon.stub(page, 'evaluateHandle').resolves({
+      evaluate: () => Promise.resolve(),
+      dispose: () => Promise.resolve(),
+    } as any);
+
+    await helper.waitForStableDom();
+
+    assert.ok(evaluateHandle.calledOnce);
+  });
+
+  it('should wait for navigation started', async () => {
+    const page = new MockPage() as unknown as CdpPage;
+    const client = page._client();
+    const on = sinon.spy(client, 'on');
+    const off = sinon.spy(client, 'off');
+    const helper = new WaitForHelper(page as unknown as Page, 1, 1);
+
+    await helper.waitForNavigationStarted();
+
+    assert.ok(on.calledOnceWith('Page.frameStartedNavigating', sinon.match.func));
+  });
+
+  it('should wait for events after action', async () => {
+    const page = new MockPage();
+    const helper = new WaitForHelper(page as unknown as Page, 1, 1);
+    const waitForNavigationStarted = sinon.stub(helper, 'waitForNavigationStarted').resolves(true);
+    const waitForNavigation = sinon.stub(page, 'waitForNavigation').resolves();
+    const waitForStableDom = sinon.stub(helper, 'waitForStableDom').resolves();
+    const action = sinon.spy();
+
+    await helper.waitForEventsAfterAction(action);
+
+    assert.ok(waitForNavigationStarted.calledOnce);
+    assert.ok(waitForNavigation.calledOnce);
+    assert.ok(waitForStableDom.calledOnce);
+    assert.ok(action.calledOnce);
+  });
+});