browser-commander 0.2.0

package/tests/unit/elements/selectors.test.js

@@ -0,0 +1,302 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import {
+  querySelector,
+  querySelectorAll,
+  findByText,
+  normalizeSelector,
+  withTextSelectorSupport,
+  waitForSelector,
+} from '../../../src/elements/selectors.js';
+import {
+  createMockPlaywrightPage,
+  createMockPuppeteerPage,
+} from '../../helpers/mocks.js';
+
+describe('selectors', () => {
+  describe('querySelector', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => querySelector({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should find element with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { count: 1 } },
+      });
+      const el = await querySelector({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.ok(el);
+    });
+
+    it('should find element with Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { button: { count: 1 } },
+      });
+      const el = await querySelector({
+        page,
+        engine: 'puppeteer',
+        selector: 'button',
+      });
+      assert.ok(el);
+    });
+
+    it('should return null when element not found with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { count: 0 } },
+      });
+      const el = await querySelector({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(el, null);
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        first: () => ({
+          count: async () => {
+            throw new Error('Execution context was destroyed');
+          },
+        }),
+      });
+      const el = await querySelector({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(el, null);
+    });
+  });
+
+  describe('querySelectorAll', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => querySelectorAll({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should find all elements with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { count: 3 } },
+      });
+      const elements = await querySelectorAll({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.ok(Array.isArray(elements));
+      assert.strictEqual(elements.length, 3);
+    });
+
+    it('should find all elements with Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { button: { count: 3 } },
+      });
+      const elements = await querySelectorAll({
+        page,
+        engine: 'puppeteer',
+        selector: 'button',
+      });
+      assert.ok(Array.isArray(elements));
+      assert.strictEqual(elements.length, 3);
+    });
+
+    it('should return empty array when no elements found', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { count: 0 } },
+      });
+      const elements = await querySelectorAll({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.ok(Array.isArray(elements));
+      assert.strictEqual(elements.length, 0);
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        count: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      });
+      const elements = await querySelectorAll({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.ok(Array.isArray(elements));
+      assert.strictEqual(elements.length, 0);
+    });
+  });
+
+  describe('findByText', () => {
+    it('should throw when text is not provided', async () => {
+      await assert.rejects(
+        () => findByText({ engine: 'playwright' }),
+        /text is required/
+      );
+    });
+
+    it('should return Playwright text selector', async () => {
+      const selector = await findByText({
+        engine: 'playwright',
+        text: 'Click me',
+        selector: 'button',
+      });
+      assert.ok(selector.includes('has-text'));
+      assert.ok(selector.includes('Click me'));
+    });
+
+    it('should return Playwright exact text selector', async () => {
+      const selector = await findByText({
+        engine: 'playwright',
+        text: 'Click me',
+        selector: 'button',
+        exact: true,
+      });
+      assert.ok(selector.includes('text-is'));
+      assert.ok(selector.includes('Click me'));
+    });
+
+    it('should return Puppeteer text selector object', async () => {
+      const selector = await findByText({
+        engine: 'puppeteer',
+        text: 'Click me',
+        selector: 'button',
+      });
+      assert.ok(typeof selector === 'object');
+      assert.strictEqual(selector._isPuppeteerTextSelector, true);
+      assert.strictEqual(selector.text, 'Click me');
+      assert.strictEqual(selector.baseSelector, 'button');
+    });
+
+    it('should use default selector when not provided', async () => {
+      const selector = await findByText({
+        engine: 'playwright',
+        text: 'Hello',
+      });
+      assert.ok(selector.includes('*'));
+    });
+  });
+
+  describe('normalizeSelector', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => normalizeSelector({ page }),
+        /selector is required/
+      );
+    });
+
+    it('should return string selector unchanged', async () => {
+      const page = createMockPlaywrightPage();
+      const result = await normalizeSelector({ page, selector: 'button' });
+      assert.strictEqual(result, 'button');
+    });
+
+    it('should return non-text-selector object unchanged', async () => {
+      const page = createMockPlaywrightPage();
+      const obj = { someKey: 'value' };
+      const result = await normalizeSelector({ page, selector: obj });
+      assert.strictEqual(result, obj);
+    });
+  });
+
+  describe('withTextSelectorSupport', () => {
+    it('should wrap function and pass through options', async () => {
+      const page = createMockPuppeteerPage();
+      let receivedOptions = null;
+      const fn = async (options) => {
+        receivedOptions = options;
+        return 'result';
+      };
+
+      const wrapped = withTextSelectorSupport(fn, 'puppeteer', page);
+      const result = await wrapped({ selector: 'button', otherOption: true });
+
+      assert.strictEqual(result, 'result');
+      assert.ok(receivedOptions);
+      assert.strictEqual(receivedOptions.selector, 'button');
+      assert.strictEqual(receivedOptions.otherOption, true);
+    });
+
+    it('should pass through string selectors unchanged for Puppeteer', async () => {
+      const page = createMockPuppeteerPage();
+      let receivedSelector = null;
+      const fn = async (options) => {
+        receivedSelector = options.selector;
+      };
+
+      const wrapped = withTextSelectorSupport(fn, 'puppeteer', page);
+      await wrapped({ selector: 'button' });
+
+      assert.strictEqual(receivedSelector, 'button');
+    });
+  });
+
+  describe('waitForSelector', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => waitForSelector({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should wait for selector with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { visible: true } },
+      });
+      const result = await waitForSelector({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+        timeout: 1000,
+      });
+      assert.strictEqual(result, true);
+    });
+
+    it('should wait for selector with Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { button: { visible: true } },
+      });
+      const result = await waitForSelector({
+        page,
+        engine: 'puppeteer',
+        selector: 'button',
+        timeout: 1000,
+      });
+      assert.strictEqual(result, true);
+    });
+
+    it('should handle navigation errors with throwOnNavigation false', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        waitFor: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      });
+
+      const result = await waitForSelector({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+        throwOnNavigation: false,
+      });
+      assert.strictEqual(result, false);
+    });
+  });
+});

package/tests/unit/elements/visibility.test.js

@@ -0,0 +1,234 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import {
+  isVisible,
+  isEnabled,
+  count,
+} from '../../../src/elements/visibility.js';
+import {
+  createMockPlaywrightPage,
+  createMockPuppeteerPage,
+} from '../../helpers/mocks.js';
+
+describe('visibility', () => {
+  describe('isVisible', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => isVisible({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should return true for visible element with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { visible: true, count: 1 } },
+      });
+      const visible = await isVisible({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(visible, true);
+    });
+
+    it('should return false for non-visible element with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { visible: false, count: 1 } },
+      });
+      const visible = await isVisible({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(visible, false);
+    });
+
+    it('should return true for visible element with Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { button: { visible: true, count: 1 } },
+      });
+      const visible = await isVisible({
+        page,
+        engine: 'puppeteer',
+        selector: 'button',
+      });
+      assert.strictEqual(visible, true);
+    });
+
+    it('should return false when element not found with Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { button: { count: 0 } },
+      });
+      const visible = await isVisible({
+        page,
+        engine: 'puppeteer',
+        selector: 'button',
+      });
+      assert.strictEqual(visible, false);
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        waitFor: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      });
+      const visible = await isVisible({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(visible, false);
+    });
+  });
+
+  describe('isEnabled', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => isEnabled({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should return true for enabled element with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { enabled: true, count: 1 } },
+      });
+      const enabled = await isEnabled({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(enabled, true);
+    });
+
+    it('should return false for disabled element with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { enabled: false, disabled: true, count: 1 } },
+      });
+      const enabled = await isEnabled({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(enabled, false);
+    });
+
+    it('should check for custom disabled classes', async () => {
+      const page = createMockPlaywrightPage({
+        elements: {
+          button: {
+            enabled: true,
+            className: 'magritte-button_loading',
+            count: 1,
+          },
+        },
+      });
+      const enabled = await isEnabled({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+        disabledClasses: ['magritte-button_loading'],
+      });
+      assert.strictEqual(enabled, false);
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        first: () => ({
+          evaluate: async () => {
+            throw new Error('Execution context was destroyed');
+          },
+        }),
+      });
+      const enabled = await isEnabled({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(enabled, false);
+    });
+  });
+
+  describe('count', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => count({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should return element count with Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { count: 5 } },
+      });
+      const c = await count({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(c, 5);
+    });
+
+    it('should return element count with Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { button: { count: 3 } },
+      });
+      const c = await count({
+        page,
+        engine: 'puppeteer',
+        selector: 'button',
+      });
+      assert.strictEqual(c, 3);
+    });
+
+    it('should return 0 when no elements found', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { count: 0 } },
+      });
+      const c = await count({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(c, 0);
+    });
+
+    it('should handle Puppeteer text selector objects', async () => {
+      const page = createMockPuppeteerPage();
+      page.evaluate = async () => 2; // Mock count result
+
+      const c = await count({
+        page,
+        engine: 'puppeteer',
+        selector: {
+          _isPuppeteerTextSelector: true,
+          baseSelector: 'button',
+          text: 'Submit',
+          exact: false,
+        },
+      });
+      assert.strictEqual(c, 2);
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        count: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      });
+      const c = await count({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.strictEqual(c, 0);
+    });
+  });
+});

package/tests/unit/factory.test.js

@@ -0,0 +1,174 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { makeBrowserCommander } from '../../src/factory.js';
+import {
+  createMockPlaywrightPage,
+  createMockPuppeteerPage,
+  createMockLogger,
+} from '../helpers/mocks.js';
+
+describe('factory', () => {
+  describe('makeBrowserCommander', () => {
+    it('should throw when page is not provided', () => {
+      assert.throws(() => makeBrowserCommander({}), /page is required/);
+    });
+
+    it('should create commander with Playwright page', () => {
+      const page = createMockPlaywrightPage();
+      page.locator = (sel) => ({
+        count: async () => 1,
+        waitFor: async () => {},
+      });
+      page.context = () => ({});
+
+      const commander = makeBrowserCommander({ page });
+
+      assert.ok(commander);
+      assert.ok(typeof commander.clickButton === 'function');
+      assert.ok(typeof commander.fillTextArea === 'function');
+      assert.ok(typeof commander.goto === 'function');
+      assert.ok(typeof commander.wait === 'function');
+    });
+
+    it('should create commander with Puppeteer page', () => {
+      const page = createMockPuppeteerPage();
+      // Make sure it doesn't have Playwright-specific methods
+      delete page.locator;
+      delete page.context;
+      page.$eval = async () => {};
+
+      const commander = makeBrowserCommander({ page });
+
+      assert.ok(commander);
+      assert.ok(typeof commander.clickButton === 'function');
+    });
+
+    it('should accept verbose option', () => {
+      const page = createMockPlaywrightPage();
+      page.locator = (sel) => ({
+        count: async () => 1,
+        waitFor: async () => {},
+      });
+      page.context = () => ({});
+
+      const commander = makeBrowserCommander({ page, verbose: true });
+
+      assert.ok(commander);
+    });
+
+    it('should have all expected methods', () => {
+      const page = createMockPlaywrightPage();
+      page.locator = (sel) => ({
+        count: async () => 1,
+        waitFor: async () => {},
+      });
+      page.context = () => ({});
+
+      const commander = makeBrowserCommander({ page });
+
+      // Core navigation
+      assert.ok(typeof commander.goto === 'function');
+      assert.ok(typeof commander.getUrl === 'function');
+
+      // Element selection
+      assert.ok(typeof commander.querySelector === 'function');
+      assert.ok(typeof commander.querySelectorAll === 'function');
+      assert.ok(typeof commander.findByText === 'function');
+
+      // Interactions
+      assert.ok(typeof commander.clickButton === 'function');
+      assert.ok(typeof commander.fillTextArea === 'function');
+
+      // Element state
+      assert.ok(typeof commander.isVisible === 'function');
+      assert.ok(typeof commander.isEnabled === 'function');
+      assert.ok(typeof commander.count === 'function');
+
+      // Content
+      assert.ok(typeof commander.textContent === 'function');
+      assert.ok(typeof commander.inputValue === 'function');
+      assert.ok(typeof commander.getAttribute === 'function');
+
+      // Utilities
+      assert.ok(typeof commander.wait === 'function');
+      assert.ok(typeof commander.evaluate === 'function');
+    });
+
+    it('should return engine type', () => {
+      const page = createMockPlaywrightPage();
+      page.locator = (sel) => ({
+        count: async () => 1,
+        waitFor: async () => {},
+      });
+      page.context = () => ({});
+
+      const commander = makeBrowserCommander({ page });
+
+      assert.ok(
+        commander.engine === 'playwright' || commander.engine === 'puppeteer'
+      );
+    });
+
+    it('should expose page object', () => {
+      const page = createMockPlaywrightPage();
+      page.locator = (sel) => ({
+        count: async () => 1,
+        waitFor: async () => {},
+      });
+      page.context = () => ({});
+
+      const commander = makeBrowserCommander({ page });
+
+      assert.strictEqual(commander.page, page);
+    });
+
+    it('should allow disabling network tracking', () => {
+      const page = createMockPlaywrightPage();
+      page.locator = (sel) => ({
+        count: async () => 1,
+        waitFor: async () => {},
+      });
+      page.context = () => ({});
+
+      const commander = makeBrowserCommander({
+        page,
+        enableNetworkTracking: false,
+      });
+
+      assert.ok(commander);
+      assert.strictEqual(commander.networkTracker, null);
+    });
+
+    it('should allow disabling navigation manager', () => {
+      const page = createMockPlaywrightPage();
+      page.locator = (sel) => ({
+        count: async () => 1,
+        waitFor: async () => {},
+      });
+      page.context = () => ({});
+
+      const commander = makeBrowserCommander({
+        page,
+        enableNavigationManager: false,
+      });
+
+      assert.ok(commander);
+      assert.strictEqual(commander.navigationManager, null);
+    });
+
+    it('should have destroy method', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = (sel) => ({
+        count: async () => 1,
+        waitFor: async () => {},
+      });
+      page.context = () => ({});
+
+      const commander = makeBrowserCommander({ page });
+
+      assert.ok(typeof commander.destroy === 'function');
+      // Should not throw
+      await commander.destroy();
+    });
+  });
+});