browser-commander 0.2.0

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

@@ -0,0 +1,318 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import {
+  textContent,
+  inputValue,
+  getAttribute,
+  getInputValue,
+  logElementInfo,
+} from '../../../src/elements/content.js';
+import {
+  createMockPlaywrightPage,
+  createMockPuppeteerPage,
+  createMockLogger,
+} from '../../helpers/mocks.js';
+
+describe('content', () => {
+  describe('textContent', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => textContent({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should return text content for Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { div: { textContent: 'Hello World', count: 1 } },
+      });
+      const text = await textContent({
+        page,
+        engine: 'playwright',
+        selector: 'div',
+      });
+      assert.strictEqual(text, 'Hello World');
+    });
+
+    it('should return text content for Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { div: { textContent: 'Hello World', count: 1 } },
+      });
+      // Override evaluate to properly return textContent for this test
+      page.evaluate = async (fn, el) =>
+        // The fn is like: el => el.textContent
+        // Return the configured text content
+        'Hello World';
+      const text = await textContent({
+        page,
+        engine: 'puppeteer',
+        selector: 'div',
+      });
+      assert.strictEqual(text, 'Hello World');
+    });
+
+    it('should return null when element not found', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { div: { count: 0 } },
+      });
+      const text = await textContent({
+        page,
+        engine: 'puppeteer',
+        selector: 'div',
+      });
+      assert.strictEqual(text, null);
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        textContent: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      });
+      const text = await textContent({
+        page,
+        engine: 'playwright',
+        selector: 'div',
+      });
+      assert.strictEqual(text, null);
+    });
+  });
+
+  describe('inputValue', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => inputValue({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should return input value for Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { input: { value: 'test value', count: 1 } },
+      });
+      const value = await inputValue({
+        page,
+        engine: 'playwright',
+        selector: 'input',
+      });
+      assert.strictEqual(value, 'test value');
+    });
+
+    it('should return input value for Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { input: { value: 'test value', count: 1 } },
+      });
+      // Override evaluate to properly return value for this test
+      page.evaluate = async (fn, el) =>
+        // The fn is like: el => el.value
+        // Return the configured value
+        'test value';
+      const value = await inputValue({
+        page,
+        engine: 'puppeteer',
+        selector: 'input',
+      });
+      assert.strictEqual(value, 'test value');
+    });
+
+    it('should return empty string when element not found', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { input: { count: 0 } },
+      });
+      const value = await inputValue({
+        page,
+        engine: 'puppeteer',
+        selector: 'input',
+      });
+      assert.strictEqual(value, '');
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        inputValue: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      });
+      const value = await inputValue({
+        page,
+        engine: 'playwright',
+        selector: 'input',
+      });
+      assert.strictEqual(value, '');
+    });
+  });
+
+  describe('getAttribute', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => getAttribute({ page, engine: 'playwright', attribute: 'href' }),
+        /selector and attribute are required/
+      );
+    });
+
+    it('should throw when attribute is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => getAttribute({ page, engine: 'playwright', selector: 'a' }),
+        /selector and attribute are required/
+      );
+    });
+
+    it('should return attribute value for Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { a: { href: 'https://example.com', count: 1 } },
+      });
+      const value = await getAttribute({
+        page,
+        engine: 'playwright',
+        selector: 'a',
+        attribute: 'href',
+      });
+      assert.strictEqual(value, 'https://example.com');
+    });
+
+    it('should return null when attribute not found', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { a: { count: 1 } },
+      });
+      const value = await getAttribute({
+        page,
+        engine: 'playwright',
+        selector: 'a',
+        attribute: 'nonexistent',
+      });
+      assert.strictEqual(value, null);
+    });
+
+    it('should return null when element not found', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { a: { count: 0 } },
+      });
+      const value = await getAttribute({
+        page,
+        engine: 'puppeteer',
+        selector: 'a',
+        attribute: 'href',
+      });
+      assert.strictEqual(value, null);
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        getAttribute: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      });
+      const value = await getAttribute({
+        page,
+        engine: 'playwright',
+        selector: 'a',
+        attribute: 'href',
+      });
+      assert.strictEqual(value, null);
+    });
+  });
+
+  describe('getInputValue', () => {
+    it('should throw when locatorOrElement is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => getInputValue({ page, engine: 'playwright' }),
+        /locatorOrElement is required/
+      );
+    });
+
+    it('should return value from locator', async () => {
+      const page = createMockPlaywrightPage();
+      const mockLocator = {
+        inputValue: async () => 'locator value',
+      };
+      const adapter = {
+        getInputValue: async () => 'adapter value',
+      };
+      const value = await getInputValue({
+        page,
+        engine: 'playwright',
+        locatorOrElement: mockLocator,
+        adapter,
+      });
+      assert.strictEqual(value, 'adapter value');
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      const mockLocator = {};
+      const adapter = {
+        getInputValue: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      };
+      const value = await getInputValue({
+        page,
+        engine: 'playwright',
+        locatorOrElement: mockLocator,
+        adapter,
+      });
+      assert.strictEqual(value, '');
+    });
+  });
+
+  describe('logElementInfo', () => {
+    it('should not throw when locatorOrElement is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      await logElementInfo({ page, engine: 'playwright', log });
+      // Should not throw
+    });
+
+    it('should log element information', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { textContent: 'Click me', count: 1 } },
+      });
+      const log = createMockLogger({ collectLogs: true });
+      const mockLocator = {
+        evaluate: async (fn) => 'BUTTON',
+        textContent: async () => 'Click me',
+      };
+      const adapter = {
+        evaluateOnElement: async () => 'BUTTON',
+        getTextContent: async () => 'Click me',
+      };
+
+      await logElementInfo({
+        page,
+        engine: 'playwright',
+        log,
+        locatorOrElement: mockLocator,
+        adapter,
+      });
+      // Should log without error
+    });
+
+    it('should handle navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      const log = createMockLogger();
+      const mockLocator = {};
+      const adapter = {
+        evaluateOnElement: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      };
+
+      await logElementInfo({
+        page,
+        engine: 'playwright',
+        log,
+        locatorOrElement: mockLocator,
+        adapter,
+      });
+      // Should not throw
+    });
+  });
+});

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

@@ -0,0 +1,236 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import {
+  createPlaywrightLocator,
+  getLocatorOrElement,
+  waitForLocatorOrElement,
+  waitForVisible,
+  locator,
+} from '../../../src/elements/locators.js';
+import {
+  createMockPlaywrightPage,
+  createMockPuppeteerPage,
+} from '../../helpers/mocks.js';
+
+describe('locators', () => {
+  describe('createPlaywrightLocator', () => {
+    it('should throw when selector is not provided', () => {
+      const page = createMockPlaywrightPage();
+      assert.throws(
+        () => createPlaywrightLocator({ page }),
+        /selector is required/
+      );
+    });
+
+    it('should create locator from simple selector', () => {
+      const page = createMockPlaywrightPage();
+      const loc = createPlaywrightLocator({ page, selector: 'button' });
+      assert.ok(loc);
+    });
+
+    it('should handle :nth-of-type selector', () => {
+      const page = createMockPlaywrightPage();
+      const loc = createPlaywrightLocator({
+        page,
+        selector: 'button:nth-of-type(2)',
+      });
+      assert.ok(loc);
+    });
+
+    it('should create locator for complex selector', () => {
+      const page = createMockPlaywrightPage();
+      const loc = createPlaywrightLocator({
+        page,
+        selector: 'div.class > span[data-id="test"]',
+      });
+      assert.ok(loc);
+    });
+  });
+
+  describe('getLocatorOrElement', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => getLocatorOrElement({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should return locator for Playwright', async () => {
+      const page = createMockPlaywrightPage();
+      const loc = await getLocatorOrElement({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+      });
+      assert.ok(loc);
+    });
+
+    it('should return element for Puppeteer', async () => {
+      const page = createMockPuppeteerPage();
+      const el = await getLocatorOrElement({
+        page,
+        engine: 'puppeteer',
+        selector: 'button',
+      });
+      assert.ok(el);
+    });
+
+    it('should return existing locator/element unchanged', async () => {
+      const page = createMockPlaywrightPage();
+      const existingLocator = { isLocator: true };
+      const result = await getLocatorOrElement({
+        page,
+        engine: 'playwright',
+        selector: existingLocator,
+      });
+      assert.strictEqual(result, existingLocator);
+    });
+
+    it('should return null for Puppeteer when element not found', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { missing: { count: 0 } },
+      });
+      const el = await getLocatorOrElement({
+        page,
+        engine: 'puppeteer',
+        selector: 'missing',
+      });
+      assert.strictEqual(el, null);
+    });
+  });
+
+  describe('waitForLocatorOrElement', () => {
+    it('should throw when selector is not provided', async () => {
+      const page = createMockPlaywrightPage();
+      await assert.rejects(
+        () => waitForLocatorOrElement({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should wait for Playwright locator to be visible', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { button: { visible: true } },
+      });
+      const loc = await waitForLocatorOrElement({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+        timeout: 1000,
+      });
+      assert.ok(loc);
+    });
+
+    it('should wait for Puppeteer element to be visible', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { button: { visible: true } },
+      });
+      const el = await waitForLocatorOrElement({
+        page,
+        engine: 'puppeteer',
+        selector: 'button',
+        timeout: 1000,
+      });
+      assert.ok(el);
+    });
+
+    it('should handle navigation errors with throwOnNavigation false', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        first: () => ({
+          waitFor: async () => {
+            throw new Error('Execution context was destroyed');
+          },
+        }),
+      });
+
+      const result = await waitForLocatorOrElement({
+        page,
+        engine: 'playwright',
+        selector: 'button',
+        throwOnNavigation: false,
+      });
+      assert.strictEqual(result, null);
+    });
+  });
+
+  describe('waitForVisible', () => {
+    it('should throw when locatorOrElement is not provided', async () => {
+      await assert.rejects(
+        () => waitForVisible({ engine: 'playwright' }),
+        /locatorOrElement is required/
+      );
+    });
+
+    it('should wait for Playwright locator visibility', async () => {
+      const mockLocator = {
+        waitFor: async () => {},
+      };
+      await waitForVisible({
+        engine: 'playwright',
+        locatorOrElement: mockLocator,
+        timeout: 1000,
+      });
+      // Should not throw
+    });
+
+    it('should handle Puppeteer elements (no-op since already fetched)', async () => {
+      const mockElement = { click: async () => {} };
+      await waitForVisible({
+        engine: 'puppeteer',
+        locatorOrElement: mockElement,
+        timeout: 1000,
+      });
+      // Should not throw
+    });
+
+    it('should throw for Puppeteer when element is null', async () => {
+      await assert.rejects(
+        () =>
+          waitForVisible({
+            engine: 'puppeteer',
+            locatorOrElement: null,
+          }),
+        /locatorOrElement is required/
+      );
+    });
+  });
+
+  describe('locator', () => {
+    it('should throw when selector is not provided', () => {
+      const page = createMockPlaywrightPage();
+      assert.throws(
+        () => locator({ page, engine: 'playwright' }),
+        /selector is required/
+      );
+    });
+
+    it('should create Playwright locator', () => {
+      const page = createMockPlaywrightPage();
+      const loc = locator({ page, engine: 'playwright', selector: 'button' });
+      assert.ok(loc);
+    });
+
+    it('should create Puppeteer locator wrapper', () => {
+      const page = createMockPuppeteerPage();
+      const loc = locator({ page, engine: 'puppeteer', selector: 'button' });
+      assert.ok(loc);
+      assert.ok(typeof loc.count === 'function');
+      assert.ok(typeof loc.click === 'function');
+      assert.ok(typeof loc.fill === 'function');
+      assert.ok(typeof loc.textContent === 'function');
+      assert.ok(typeof loc.nth === 'function');
+      assert.ok(typeof loc.first === 'function');
+      assert.ok(typeof loc.last === 'function');
+    });
+
+    it('should allow chained nth calls on Puppeteer wrapper', () => {
+      const page = createMockPuppeteerPage();
+      const loc = locator({ page, engine: 'puppeteer', selector: 'button' });
+      const nthLoc = loc.nth(2);
+      assert.ok(nthLoc);
+      assert.ok(typeof nthLoc.click === 'function');
+    });
+  });
+});