browser-commander 0.17.2 → 0.19.0

package/tests/unit/core/dialog-manager.test.js

@@ -266,10 +266,98 @@ describe('dialog-manager', () => {
     });
   });
 
+  describe('observeDialogs', () => {
+    /**
+     * A manager already listening to the page, as every observer test needs.
+     *
+     * @returns {Object} The dialog manager
+     */
+    const listening = () => {
+      const manager = createDialogManager({ page, engine: 'playwright', log });
+      manager.startListening();
+      return manager;
+    };
+
+    it('should still auto-dismiss when only observers are watching', async () => {
+      const manager = listening();
+
+      const seen = [];
+      manager.observeDialogs((dialog) => seen.push(dialog.message()));
+      const dialog = createMockDialog({ message: 'watched' });
+      await page.emit('dialog', dialog);
+
+      assert.deepStrictEqual(seen, ['watched']);
+      // Watching a dialog must not make the watcher responsible for it, or a
+      // traced run leaves the page waiting for an answer an untraced run got.
+      assert.strictEqual(dialog._wasDismissed(), true);
+    });
+
+    it('should tell observers about a dialog a handler answers', async () => {
+      const manager = listening();
+
+      const seen = [];
+      manager.observeDialogs((dialog) => seen.push(dialog.type()));
+      manager.onDialog(async (dialog) => dialog.accept('ok'));
+      const dialog = createMockDialog({ type: 'prompt' });
+      await page.emit('dialog', dialog);
+
+      assert.deepStrictEqual(seen, ['prompt']);
+      assert.strictEqual(dialog._acceptText(), 'ok');
+      assert.strictEqual(dialog._wasDismissed(), false);
+    });
+
+    it('should keep going when an observer throws', async () => {
+      const manager = listening();
+
+      let secondObserverCalled = false;
+      manager.observeDialogs(() => {
+        throw new Error('observer failed');
+      });
+      manager.observeDialogs(() => {
+        secondObserverCalled = true;
+      });
+      const dialog = createMockDialog();
+      await page.emit('dialog', dialog);
+
+      assert.strictEqual(secondObserverCalled, true);
+      assert.strictEqual(dialog._wasDismissed(), true);
+    });
+
+    it('should stop telling an observer that was removed', async () => {
+      const manager = listening();
+
+      let calls = 0;
+      const stop = manager.observeDialogs(() => {
+        calls += 1;
+      });
+      await page.emit('dialog', createMockDialog());
+      stop();
+      await page.emit('dialog', createMockDialog());
+
+      assert.strictEqual(calls, 1);
+    });
+
+    it('should refuse an observer that is not a function', () => {
+      const manager = createDialogManager({ page, engine: 'playwright', log });
+
+      assert.throws(() => manager.observeDialogs('nope'), /must be a function/);
+    });
+  });
+
   describe('integration with makeBrowserCommander', () => {
-    it('should expose onDialog on commander', async () => {
+    /**
+     * A commander driving the suite's page.
+     *
+     * @param {Object} [options] - Extra options for `makeBrowserCommander`
+     * @returns {Promise<Object>} The commander
+     */
+    const commanderFor = async (options = {}) => {
       const { makeBrowserCommander } = await import('../../../src/factory.js');
-      const commander = makeBrowserCommander({ page, verbose: false });
+      return makeBrowserCommander({ page, verbose: false, ...options });
+    };
+
+    it('should expose onDialog on commander', async () => {
+      const commander = await commanderFor();
 
       assert.ok(typeof commander.onDialog === 'function');
       assert.ok(typeof commander.offDialog === 'function');
@@ -278,8 +366,7 @@ describe('dialog-manager', () => {
     });
 
     it('should handle dialog via commander.onDialog', async () => {
-      const { makeBrowserCommander } = await import('../../../src/factory.js');
-      const commander = makeBrowserCommander({ page, verbose: false });
+      const commander = await commanderFor();
 
       let handlerCalled = false;
       commander.onDialog(async (dialog) => {
@@ -296,13 +383,34 @@ describe('dialog-manager', () => {
       await commander.destroy();
     });
 
+    it('should expose observeDialogs on commander', async () => {
+      const commander = await commanderFor();
+
+      const seen = [];
+      commander.observeDialogs((dialog) => seen.push(dialog.message()));
+      const dialog = createMockDialog({ message: 'from the commander' });
+      await page.emit('dialog', dialog);
+
+      assert.deepStrictEqual(seen, ['from the commander']);
+      assert.strictEqual(dialog._wasDismissed(), true);
+
+      await commander.destroy();
+    });
+
+    it('should throw observeDialogs when enableDialogManager is false', async () => {
+      const commander = await commanderFor({ enableDialogManager: false });
+
+      assert.throws(
+        () => commander.observeDialogs(() => {}),
+        /enableDialogManager/
+      );
+      // Removing an observer from a manager that never existed is a no-op,
+      // so cleanup code does not have to know whether tracing was on.
+      assert.doesNotThrow(() => commander.unobserveDialogs(() => {}));
+    });
+
     it('should throw onDialog when enableDialogManager is false', async () => {
-      const { makeBrowserCommander } = await import('../../../src/factory.js');
-      const commander = makeBrowserCommander({
-        page,
-        verbose: false,
-        enableDialogManager: false,
-      });
+      const commander = await commanderFor({ enableDialogManager: false });
 
       assert.throws(() => commander.onDialog(() => {}), /enableDialogManager/);
     });

package/tests/unit/core/navigation-manager.test.js

@@ -4,7 +4,33 @@ import { createNavigationManager } from '../../../src/core/navigation-manager.js
 import {
   createMockPlaywrightPage,
   createMockLogger,
+  createMockNetworkTracker,
 } from '../../helpers/mocks.js';
+import { READINESS_STATUS } from '../../../src/core/readiness.js';
+
+/**
+ * Build a navigation manager wired to a network tracker whose idle wait is
+ * fully controlled by the test.
+ */
+function createManagerWithNetwork(options = {}) {
+  const { idle = true, onIdleWait = () => {} } = options;
+  const page = createMockPlaywrightPage();
+  const log = createMockLogger();
+  const networkTracker = createMockNetworkTracker();
+  networkTracker.waitForNetworkIdle = async (opts = {}) => {
+    onIdleWait(opts);
+    return typeof idle === 'function' ? await idle(opts) : idle;
+  };
+
+  const manager = createNavigationManager({
+    page,
+    engine: 'playwright',
+    log,
+    networkTracker,
+  });
+  manager.configure({ redirectStabilizationTime: 0 });
+  return { manager, page, log, networkTracker };
+}
 
 describe('navigation manager', () => {
   describe('setContent', () => {
@@ -59,4 +85,140 @@ describe('navigation manager', () => {
       await assert.doesNotReject(() => manager.setContent({ html: '' }));
     });
   });
+
+  describe('waitForReady', () => {
+    it('should never extend the caller deadline beyond the timeout', async () => {
+      // Regression test for issue #89: the old implementation waited
+      // `Math.max(60000, timeout - elapsed)`, so a 500ms budget could block for
+      // a full minute.
+      const idleTimeouts = [];
+      const { manager } = createManagerWithNetwork({
+        idle: true,
+        onIdleWait: (opts) => idleTimeouts.push(opts.timeout),
+      });
+
+      await manager.waitForReady({ timeout: 1000, reason: 'deadline test' });
+
+      assert.strictEqual(idleTimeouts.length, 1);
+      assert.ok(
+        idleTimeouts[0] <= 1000,
+        `network idle timeout ${idleTimeouts[0]} exceeded the 1000ms budget`
+      );
+    });
+
+    it('should report timed_out instead of claiming the page is ready', async () => {
+      // Regression test for issue #89: `waitForPageReady` logged "Page ready"
+      // and returned true even after network idle had failed.
+      const { manager } = createManagerWithNetwork({
+        // Burn the whole remaining budget, the way a real idle wait does.
+        idle: async (opts) => {
+          await new Promise((resolve) => setTimeout(resolve, opts.timeout));
+          return false;
+        },
+      });
+
+      const result = await manager.waitForReady({
+        timeout: 600,
+        reason: 'failure test',
+      });
+
+      assert.strictEqual(result.ready, false);
+      assert.strictEqual(result.status, READINESS_STATUS.TIMED_OUT);
+      assert.ok(result.checks.failed.includes('networkIdleFor'));
+      assert.ok(
+        result.elapsedMs < 3000,
+        `wait took ${result.elapsedMs}ms for a 600ms budget`
+      );
+    });
+
+    it('should report failed when a check fails before the deadline', async () => {
+      const { manager } = createManagerWithNetwork({ idle: false });
+
+      const result = await manager.waitForReady({ timeout: 5000 });
+
+      assert.strictEqual(result.ready, false);
+      assert.strictEqual(result.status, READINESS_STATUS.FAILED);
+      assert.ok(result.checks.failed.includes('networkIdleFor'));
+    });
+
+    it('should not emit onPageReady after a failed wait', async () => {
+      // Regression test for issue #89: cleanup and the ready event were both
+      // owned by completeNavigation(), so failing waits still announced ready.
+      const { manager } = createManagerWithNetwork({ idle: false });
+      const events = [];
+      manager.on('onPageReady', () => events.push('pageReady'));
+      manager.on('onNavigationComplete', (payload) =>
+        events.push(`complete:${payload.ready}`)
+      );
+
+      const ready = await manager.navigate({
+        url: 'https://example.com',
+        timeout: 1000,
+      });
+
+      assert.strictEqual(ready, false);
+      assert.ok(!events.includes('pageReady'));
+      assert.ok(events.includes('complete:false'));
+      assert.strictEqual(manager.isNavigating(), false);
+    });
+
+    it('should emit onPageReady exactly once when every check passes', async () => {
+      const { manager } = createManagerWithNetwork({ idle: true });
+      const events = [];
+      manager.on('onPageReady', () => events.push('pageReady'));
+
+      const result = await manager.waitForReady({ timeout: 2000 });
+
+      assert.strictEqual(result.ready, true);
+      assert.strictEqual(result.status, READINESS_STATUS.READY);
+      assert.deepStrictEqual(events, ['pageReady']);
+      assert.ok(result.checks.satisfied.includes('networkIdleFor'));
+    });
+
+    it('should record evidence for every check it ran', async () => {
+      const { manager } = createManagerWithNetwork({ idle: true });
+
+      const result = await manager.waitForReady({ timeout: 2000 });
+
+      assert.ok(Array.isArray(result.evidence));
+      assert.ok(result.evidence.length >= 2);
+      for (const entry of result.evidence) {
+        assert.strictEqual(typeof entry.name, 'string');
+        assert.strictEqual(typeof entry.satisfied, 'boolean');
+        assert.strictEqual(typeof entry.elapsedMs, 'number');
+      }
+    });
+
+    it('should stop running checks once the deadline is exhausted', async () => {
+      let secondCheckRan = false;
+      const { manager } = createManagerWithNetwork({ idle: true });
+
+      const slow = {
+        name: 'slow',
+        async run({ deadline }) {
+          await new Promise((resolve) => setTimeout(resolve, 60));
+          return {
+            satisfied: false,
+            detail: { remaining: deadline.remainingMs() },
+          };
+        },
+      };
+      const second = {
+        name: 'second',
+        async run() {
+          secondCheckRan = true;
+          return { satisfied: true };
+        },
+      };
+
+      const result = await manager.waitForReady({
+        timeout: 50,
+        checks: [slow, second],
+      });
+
+      assert.strictEqual(result.ready, false);
+      assert.strictEqual(secondCheckRan, false);
+      assert.ok(result.checks.pending.includes('second'));
+    });
+  });
 });