browser-commander 0.2.0

package/tests/unit/bindings.test.js

@@ -0,0 +1,218 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { createBoundFunctions } from '../../src/bindings.js';
+import {
+  createMockPlaywrightPage,
+  createMockLogger,
+  createMockNavigationManager,
+  createMockNetworkTracker,
+} from '../helpers/mocks.js';
+
+describe('bindings', () => {
+  describe('createBoundFunctions', () => {
+    it('should create bindings with minimal options', () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+
+      const bindings = createBoundFunctions({
+        page,
+        engine: 'playwright',
+        log,
+      });
+
+      assert.ok(bindings);
+      assert.ok(typeof bindings === 'object');
+    });
+
+    it('should create bindings with all options', () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      const navigationManager = createMockNavigationManager();
+      const networkTracker = createMockNetworkTracker();
+
+      const bindings = createBoundFunctions({
+        page,
+        engine: 'playwright',
+        log,
+        verbose: true,
+        navigationManager,
+        networkTracker,
+      });
+
+      assert.ok(bindings);
+    });
+
+    it('should have all expected bound functions', () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+
+      const bindings = createBoundFunctions({
+        page,
+        engine: 'playwright',
+        log,
+      });
+
+      // Verify it returns an object with functions
+      assert.ok(bindings);
+      assert.ok(typeof bindings === 'object');
+
+      // Navigation
+      assert.ok(
+        typeof bindings.goto === 'function',
+        'goto should be a function'
+      );
+      assert.ok(
+        typeof bindings.getUrl === 'function',
+        'getUrl should be a function'
+      );
+      assert.ok(
+        typeof bindings.waitForNavigation === 'function',
+        'waitForNavigation should be a function'
+      );
+
+      // Selectors
+      assert.ok(
+        typeof bindings.querySelector === 'function',
+        'querySelector should be a function'
+      );
+      assert.ok(
+        typeof bindings.querySelectorAll === 'function',
+        'querySelectorAll should be a function'
+      );
+      assert.ok(
+        typeof bindings.findByText === 'function',
+        'findByText should be a function'
+      );
+      assert.ok(
+        typeof bindings.waitForSelector === 'function',
+        'waitForSelector should be a function'
+      );
+
+      // Interactions
+      assert.ok(
+        typeof bindings.clickButton === 'function',
+        'clickButton should be a function'
+      );
+      assert.ok(
+        typeof bindings.fillTextArea === 'function',
+        'fillTextArea should be a function'
+      );
+      assert.ok(
+        typeof bindings.scrollIntoViewIfNeeded === 'function',
+        'scrollIntoViewIfNeeded should be a function'
+      );
+
+      // Element state
+      assert.ok(
+        typeof bindings.isVisible === 'function',
+        'isVisible should be a function'
+      );
+      assert.ok(
+        typeof bindings.isEnabled === 'function',
+        'isEnabled should be a function'
+      );
+      assert.ok(
+        typeof bindings.count === 'function',
+        'count should be a function'
+      );
+
+      // Content
+      assert.ok(
+        typeof bindings.textContent === 'function',
+        'textContent should be a function'
+      );
+      assert.ok(
+        typeof bindings.inputValue === 'function',
+        'inputValue should be a function'
+      );
+      assert.ok(
+        typeof bindings.getAttribute === 'function',
+        'getAttribute should be a function'
+      );
+
+      // Utilities
+      assert.ok(
+        typeof bindings.wait === 'function',
+        'wait should be a function'
+      );
+      assert.ok(
+        typeof bindings.evaluate === 'function',
+        'evaluate should be a function'
+      );
+    });
+
+    it('should pre-bind page and engine to functions', async () => {
+      const page = createMockPlaywrightPage({ url: 'https://example.com' });
+      const log = createMockLogger();
+
+      const bindings = createBoundFunctions({
+        page,
+        engine: 'playwright',
+        log,
+      });
+
+      // getUrl should work without passing page
+      const url = bindings.getUrl();
+      assert.strictEqual(url, 'https://example.com');
+    });
+
+    it('should pre-bind log to functions', async () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger({ collectLogs: true });
+
+      const bindings = createBoundFunctions({
+        page,
+        engine: 'playwright',
+        log,
+      });
+
+      // wait should work without passing log
+      await bindings.wait({ ms: 1 });
+      // Should not throw
+    });
+
+    it('should allow verbose option', () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+
+      const bindings = createBoundFunctions({
+        page,
+        engine: 'playwright',
+        log,
+        verbose: true,
+      });
+
+      assert.ok(bindings);
+    });
+
+    it('should integrate with navigationManager when provided', () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      const navigationManager = createMockNavigationManager();
+
+      const bindings = createBoundFunctions({
+        page,
+        engine: 'playwright',
+        log,
+        navigationManager,
+      });
+
+      assert.ok(bindings);
+    });
+
+    it('should integrate with networkTracker when provided', () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      const networkTracker = createMockNetworkTracker();
+
+      const bindings = createBoundFunctions({
+        page,
+        engine: 'playwright',
+        log,
+        networkTracker,
+      });
+
+      assert.ok(bindings);
+    });
+  });
+});

package/tests/unit/browser/navigation.test.js

@@ -0,0 +1,345 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import {
+  defaultNavigationVerification,
+  verifyNavigation,
+  waitForUrlStabilization,
+  goto,
+  waitForNavigation,
+  waitForPageReady,
+  waitAfterAction,
+} from '../../../src/browser/navigation.js';
+import {
+  createMockPlaywrightPage,
+  createMockLogger,
+  createMockNavigationManager,
+  createMockNetworkTracker,
+} from '../../helpers/mocks.js';
+
+describe('navigation', () => {
+  describe('defaultNavigationVerification', () => {
+    it('should verify exact URL match', async () => {
+      const page = createMockPlaywrightPage({
+        url: 'https://example.com/page',
+      });
+      const result = await defaultNavigationVerification({
+        page,
+        expectedUrl: 'https://example.com/page',
+      });
+      assert.strictEqual(result.verified, true);
+      assert.ok(result.reason.includes('exact'));
+    });
+
+    it('should verify URL pattern match', async () => {
+      const page = createMockPlaywrightPage({
+        url: 'https://example.com/page?foo=bar',
+      });
+      const result = await defaultNavigationVerification({
+        page,
+        expectedUrl: 'https://example.com/page',
+      });
+      assert.strictEqual(result.verified, true);
+    });
+
+    it('should fail verification on URL mismatch', async () => {
+      const page = createMockPlaywrightPage({
+        url: 'https://example.com/other',
+      });
+      const result = await defaultNavigationVerification({
+        page,
+        expectedUrl: 'https://example.com/page',
+      });
+      assert.strictEqual(result.verified, false);
+      assert.ok(result.reason.includes('mismatch'));
+    });
+
+    it('should verify URL changed from start', async () => {
+      const page = createMockPlaywrightPage({ url: 'https://example.com/new' });
+      const result = await defaultNavigationVerification({
+        page,
+        startUrl: 'https://example.com/old',
+      });
+      assert.strictEqual(result.verified, true);
+    });
+
+    it('should verify navigation completed without expectations', async () => {
+      const page = createMockPlaywrightPage({ url: 'https://example.com' });
+      const result = await defaultNavigationVerification({
+        page,
+      });
+      assert.strictEqual(result.verified, true);
+    });
+  });
+
+  describe('verifyNavigation', () => {
+    it('should verify navigation with retry logic', async () => {
+      const page = createMockPlaywrightPage({
+        url: 'https://example.com/target',
+      });
+      const log = createMockLogger();
+
+      const result = await verifyNavigation({
+        page,
+        expectedUrl: 'https://example.com/target',
+        timeout: 100,
+        log,
+      });
+
+      assert.strictEqual(result.verified, true);
+      assert.ok(result.attempts >= 1);
+    });
+
+    it('should fail after timeout', async () => {
+      const page = createMockPlaywrightPage({
+        url: 'https://example.com/wrong',
+      });
+      const log = createMockLogger();
+
+      const result = await verifyNavigation({
+        page,
+        expectedUrl: 'https://example.com/target',
+        timeout: 50,
+        retryInterval: 10,
+        log,
+      });
+
+      assert.strictEqual(result.verified, false);
+    });
+  });
+
+  describe('waitForUrlStabilization', () => {
+    it('should delegate to navigationManager if available', async () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      const wait = async () => {};
+      const navigationManager = createMockNavigationManager();
+      let waitForPageReadyCalled = false;
+      navigationManager.waitForPageReady = async () => {
+        waitForPageReadyCalled = true;
+        return true;
+      };
+
+      const result = await waitForUrlStabilization({
+        page,
+        log,
+        wait,
+        navigationManager,
+      });
+
+      assert.strictEqual(waitForPageReadyCalled, true);
+      assert.strictEqual(result, true);
+    });
+
+    it('should use polling approach without navigationManager', async () => {
+      const page = createMockPlaywrightPage({ url: 'https://example.com' });
+      const log = createMockLogger();
+      const wait = async () => {};
+
+      const result = await waitForUrlStabilization({
+        page,
+        log,
+        wait,
+        stableChecks: 1,
+        checkInterval: 10,
+        timeout: 100,
+      });
+
+      assert.strictEqual(result, true);
+    });
+  });
+
+  describe('goto', () => {
+    it('should throw when url is not provided', async () => {
+      const page = createMockPlaywrightPage();
+
+      await assert.rejects(() => goto({ page }), /url is required/);
+    });
+
+    it('should navigate using navigationManager', async () => {
+      const page = createMockPlaywrightPage({
+        url: 'https://example.com/target',
+      });
+      const log = createMockLogger();
+      const navigationManager = createMockNavigationManager();
+      let navigateCalled = false;
+      navigationManager.navigate = async ({ url }) => {
+        navigateCalled = true;
+        return true;
+      };
+
+      const result = await goto({
+        page,
+        navigationManager,
+        log,
+        url: 'https://example.com/target',
+        verify: false,
+      });
+
+      assert.strictEqual(navigateCalled, true);
+      assert.strictEqual(result.navigated, true);
+    });
+
+    it('should navigate without navigationManager', async () => {
+      const page = createMockPlaywrightPage({
+        url: 'https://example.com/target',
+      });
+      const log = createMockLogger();
+      let gotoCalled = false;
+      page.goto = async () => {
+        gotoCalled = true;
+      };
+
+      const result = await goto({
+        page,
+        log,
+        url: 'https://example.com/target',
+        waitForStableUrlBefore: false,
+        waitForStableUrlAfter: false,
+        verify: false,
+      });
+
+      assert.strictEqual(gotoCalled, true);
+      assert.strictEqual(result.navigated, true);
+    });
+  });
+
+  describe('waitForNavigation', () => {
+    it('should delegate to navigationManager if available', async () => {
+      const page = createMockPlaywrightPage();
+      const navigationManager = createMockNavigationManager();
+      let waitCalled = false;
+      navigationManager.waitForNavigation = async () => {
+        waitCalled = true;
+        return true;
+      };
+
+      const result = await waitForNavigation({
+        page,
+        navigationManager,
+      });
+
+      assert.strictEqual(waitCalled, true);
+      assert.strictEqual(result, true);
+    });
+
+    it('should use page.waitForNavigation without navigationManager', async () => {
+      const page = createMockPlaywrightPage();
+      let waitCalled = false;
+      page.waitForNavigation = async () => {
+        waitCalled = true;
+      };
+
+      const result = await waitForNavigation({ page });
+
+      assert.strictEqual(waitCalled, true);
+      assert.strictEqual(result, true);
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.waitForNavigation = async () => {
+        throw new Error('Execution context was destroyed');
+      };
+
+      const result = await waitForNavigation({ page });
+
+      assert.strictEqual(result, false);
+    });
+  });
+
+  describe('waitForPageReady', () => {
+    it('should delegate to navigationManager if available', async () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      const wait = async () => {};
+      const navigationManager = createMockNavigationManager();
+      let waitCalled = false;
+      navigationManager.waitForPageReady = async () => {
+        waitCalled = true;
+        return true;
+      };
+
+      const result = await waitForPageReady({
+        page,
+        log,
+        wait,
+        navigationManager,
+      });
+
+      assert.strictEqual(waitCalled, true);
+      assert.strictEqual(result, true);
+    });
+
+    it('should use networkTracker if navigationManager not available', async () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      const wait = async () => {};
+      const networkTracker = createMockNetworkTracker();
+      let waitCalled = false;
+      networkTracker.waitForNetworkIdle = async () => {
+        waitCalled = true;
+        return true;
+      };
+
+      const result = await waitForPageReady({
+        page,
+        log,
+        wait,
+        networkTracker,
+      });
+
+      assert.strictEqual(waitCalled, true);
+      assert.strictEqual(result, true);
+    });
+
+    it('should use minimal fallback without both managers', async () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      const wait = async () => {};
+
+      const result = await waitForPageReady({
+        page,
+        log,
+        wait,
+      });
+
+      assert.strictEqual(result, true);
+    });
+  });
+
+  describe('waitAfterAction', () => {
+    it('should detect URL change as navigation', async () => {
+      const page = createMockPlaywrightPage({ url: 'https://example.com/new' });
+      const log = createMockLogger();
+      const wait = async () => {};
+
+      const result = await waitAfterAction({
+        page,
+        log,
+        wait,
+        navigationCheckDelay: 0,
+      });
+
+      // Page URL is stable, so no navigation detected
+      assert.ok(typeof result.navigated === 'boolean');
+      assert.ok(typeof result.ready === 'boolean');
+    });
+
+    it('should wait for network idle without navigation', async () => {
+      const page = createMockPlaywrightPage({ url: 'https://example.com' });
+      const log = createMockLogger();
+      const wait = async () => {};
+      const networkTracker = createMockNetworkTracker();
+
+      const result = await waitAfterAction({
+        page,
+        log,
+        wait,
+        networkTracker,
+        navigationCheckDelay: 0,
+      });
+
+      assert.ok(typeof result.ready === 'boolean');
+    });
+  });
+});

package/tests/unit/core/constants.test.js

@@ -0,0 +1,72 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { CHROME_ARGS, TIMING } from '../../../src/core/constants.js';
+
+describe('constants', () => {
+  describe('CHROME_ARGS', () => {
+    it('should be an array', () => {
+      assert.ok(Array.isArray(CHROME_ARGS));
+    });
+
+    it('should contain expected browser arguments', () => {
+      assert.ok(CHROME_ARGS.includes('--disable-infobars'));
+      assert.ok(CHROME_ARGS.includes('--no-first-run'));
+      assert.ok(CHROME_ARGS.includes('--no-default-browser-check'));
+    });
+
+    it('should contain crash-related flags', () => {
+      assert.ok(CHROME_ARGS.includes('--disable-session-crashed-bubble'));
+      assert.ok(CHROME_ARGS.includes('--hide-crash-restore-bubble'));
+      assert.ok(CHROME_ARGS.includes('--disable-crash-restore'));
+    });
+
+    it('should have at least 5 arguments', () => {
+      assert.ok(CHROME_ARGS.length >= 5);
+    });
+  });
+
+  describe('TIMING', () => {
+    it('should be an object', () => {
+      assert.ok(typeof TIMING === 'object');
+    });
+
+    it('should have SCROLL_ANIMATION_WAIT property', () => {
+      assert.ok(typeof TIMING.SCROLL_ANIMATION_WAIT === 'number');
+      assert.ok(TIMING.SCROLL_ANIMATION_WAIT > 0);
+    });
+
+    it('should have DEFAULT_WAIT_AFTER_SCROLL property', () => {
+      assert.ok(typeof TIMING.DEFAULT_WAIT_AFTER_SCROLL === 'number');
+      assert.ok(TIMING.DEFAULT_WAIT_AFTER_SCROLL > 0);
+    });
+
+    it('should have VISIBILITY_CHECK_TIMEOUT property', () => {
+      assert.ok(typeof TIMING.VISIBILITY_CHECK_TIMEOUT === 'number');
+      assert.ok(TIMING.VISIBILITY_CHECK_TIMEOUT > 0);
+    });
+
+    it('should have DEFAULT_TIMEOUT property', () => {
+      assert.ok(typeof TIMING.DEFAULT_TIMEOUT === 'number');
+      assert.ok(TIMING.DEFAULT_TIMEOUT >= 1000);
+    });
+
+    it('should have VERIFICATION_TIMEOUT property', () => {
+      assert.ok(typeof TIMING.VERIFICATION_TIMEOUT === 'number');
+      assert.ok(TIMING.VERIFICATION_TIMEOUT > 0);
+    });
+
+    it('should have VERIFICATION_RETRY_INTERVAL property', () => {
+      assert.ok(typeof TIMING.VERIFICATION_RETRY_INTERVAL === 'number');
+      assert.ok(TIMING.VERIFICATION_RETRY_INTERVAL > 0);
+    });
+
+    it('should have reasonable timeout values', () => {
+      // Verification retry should be shorter than verification timeout
+      assert.ok(
+        TIMING.VERIFICATION_RETRY_INTERVAL < TIMING.VERIFICATION_TIMEOUT
+      );
+      // Scroll animation wait should be relatively short
+      assert.ok(TIMING.SCROLL_ANIMATION_WAIT < 1000);
+    });
+  });
+});